一、面向对象
1、Java是一种面向对象的语言
2、对象：真实存在唯一的事物
3、类： 实际就是对某种类型事物的共性属性与行为的抽取。 抽象的概念…. 车
4、面向对象的计算机语言核心思想： 找适合的对象做适合的事情
5、自定义类创建对象的三步骤
① 自定义类 。
格式：
class 类名{
事物的公共属性使用成员变量描述。
事物的公共行为使用函数描述。
}② 通过自定义类创建对象。
格式： 类名 变量名 = new 类名();
③ 访问(设置)对象的属性或者调用对象的方法
访问对象属性的格式：对象.属性名
设置对象的属性：对象.属性名 = 数据
调用对象的功能对象.函数名()
6、数据类型的默认初始值
| 数据类型 | 默认初始值 |
|---|---|
| int | 0 |
| float | 0.0f |
| double | 0.0 |
| char | ’ ‘ |
| String(引用数据类型) | null |
| boolean | false |
7、需求： 描述一个车与修车厂两个事物，
车具备的公共属性:轮子数、 名字、 颜色 ，还具备跑的功能行为。跑之前要检测轮子是否少于了4个，如果少于了4个，那么要送到修车厂修理，修车厂修理之后，车的轮子数要补回来4个。 然后车就继续的跑起来。
修车厂： 具备公共属性： 名字、 地址、 电话。公共的行为： 修车。
//车类
class Car{
//事物的公共属性使用成员变量描述
String name ; // 名字
String color; //名字
int wheel; //轮子数
//事物的公共行为使用函数描述
public void run(){
if(wheel>=4){
System.out.println(name+wheel+"个轮子飞快跑起来..");
}else{
System.out.println(name+"不够4个轮子了，赶快去修理");
}
}
}
//修车厂
class CarFactory{
String name;//名字
String address;//地址
String tel; //电话
//修车公共行为需要包括返回值类型、未知的参数
public void repair(Car c){
if(c.wheel>=4){
System.out.println("告诉你，费了很大力气修好了，给钱！");
}else
c.wheel = 4;
System.out.println("修好了，给钱！");
}
}
}
class Demo7.1{
public static void main(String[] args){
Car c = new Car();
c.name = "奔驰";//给车对象赋予属性值
c.color = "黑色";
c.wheel = 4;
c.run();
c.wheel = 3;
c.run();
//创建修车厂对象
CarFactory f = new CarFactory();
//给修车厂赋予属性值
f.name = "哈哈哈修车厂";
f.address = "江苏镇江";
f.tel = "0527-12345678";
//调用修车的修车
f.repair(c);
c.run();
}
}二、匿名对象
1、匿名对象：没有引用类型变量指向的对象称作为匿名对象。
2、匿名对象要注意的事项
① 我们一般不会给匿名对象赋予属性值，因为永远无法获取到。
② 两个匿名对象永远都不可能是同一个对象。
3、匿名对象好处：简化书写，可以尽快释放内存空间。
4、匿名对象的应用场景
① 如果一个对象需要调用一个方法一次的时候，而调用完这个方法之后，该对象就不再使用了，这时候可以使用匿名对象。
② 可以作为实参调用一个函数。
//学生类
class Student{
int num; //学号
String name; //名字
public void study(){
System.out.println("好好学习!");
}
}
class Demo7.2{
public static void main(String[] args){
new Student().name = "张三"; //匿名对象
System.out.println(Student().name); //null
System.out.println(new Student() == new Student()) ; //false
// "==" 用于引用类型变量时，比较的是内存地址。判断两个对象是否为同一个对象
new Student().study();//调用Student的study方法
}
}三、封装
1、面向对象三大特征：封装、继承、多态
2、权限修饰符：权限修饰符就是控制变量可见范围的。
public：公共的，public修饰的成员变量或者方法任何人都可以直接访问。
private：私有的，private修饰的成员变量或者方法只能在本类中进行直接访问。
3、封装的步骤
① 使用private修饰需要被封装的属性。
② 提供一个公共的方法设置或者获取该私有的成员属性。
set属性名(); [设置属性]
get属性名(); [获取属性]
4、疑问： 封装一定要提供get或者set方法吗？
不一定， 根据需求而定的。
5、规范 ： 在现实开发中一般实体类的所有成员属性（成员变量）都要封装起来。
实体类：实体类就是用于描述一类事物的就称作为实体类。
6、封装的好处：提高数据的安全性、操作简单、隐藏了实现
class MyMember{
public String name; //名字
private String sex; //性别
public int salary; //薪水
//定义一个公共的方法设置sex属性
public void setSex(String s){
if (s.equals("男")||s.equals("女")){ //注意：如果比较两个字符串的内容是否一致，不要使用==比较，使用equals方法。
sex = s;
}else{
//默认是男
sex = "男";
}
}
//定义一个公共的方法获取sex属性
public String getSex(){
return sex;
}
//聊天
public void talk(){
System.out.println(name+"聊得非常开心");
}
}
class Demo7.3{
public static void main(String[] args){
MyMember m = new MyMember();
m.name="李四";
m.setSex("女");
m.salary = 8000;
System.out.println("姓名："+ m.name+" 性别："+ m.getSex()+" 薪水："+ m.salary);
}
}
7、需求： 使用java类描述一个计算器类，计算器具备操作数1， 操作数2 、操作符三个公共的属性，还具备计算的功能行为。要求： 不能直接对操作数1，操作数2，运算符这些属性进行直接的赋值，要封装起来。(+ - * / )
//计算器类
class Calculator{
private int num1; //操作数1
private int num2; //操作数2
private char option ; //运算符
//提供公共的方法设置属性值....
public void initCalculator(int n1 , int n2 , char op){ //初始化计算器
num1 = n1;
num2 = n2;
if(op=='+'||op=='-'||op=='*'||op=='/'){
option = op;
}else{
option = '+';
}
}
//计算的功能
public void calculate(){
switch(option){
case '+':
System.out.println("做加法运算,结果是："+(num1+num2));
break;
case '-':
System.out.println("做减法运算,结果是："+(num1-num2));
break;
case '*':
System.out.println("做乘法运算,结果是："+(num1*num2));
break;
case '/':
System.out.println("做除法运算,结果是："+(num1/num2));
break;
}
}
}
class Demo7.4{
public static void main(String[] args){
//创建了一个计算器对象
Calculator c = new Calculator();
//设置属性值
c.initCalculator(1,2,'+');
//调用计算器的计算功能
c.calculate();
}
}