中国菲律宾大使馆电话号码_学电商一般月收入多少_赣州seo顾问_河南今日头条新闻最新

面向对象 - 封装

前面我们的思想都是面向过程编程，现在开始学习面向对象编程
什么是对象? 对象：一种特殊的数据结构，用来记住一个事物的数据，从而代表该事物

面向对象编程的快速入门

第一步：设计对象的模板【设计图】：类（类是对象的抽象，用来描述一组对象的共同特征）

类中可以定义成员变量、成员方法
成员变量：类中定义的变量
局部变量：方法中定义的变量

// 这是一个student类
public class Student {// 成员变量：又称对象的属性，用来描述对象的特征String name;    // 姓名int age;        // 年龄String sex;    // 性别int chinese;    // 语文成绩int math;       // 数学成绩// 成员方法：用来描述对象的行为public void sum(){System.out.println("总分：" + (chinese + math));}public void avg(){System.out.println("平均分：" + (chinese + math) / 2);}
}

第二步：每new一次类就得到一个新对象

public class Test1 {public static void main(String[] args) {Student s1 = new Student();     // 创建Student对象s1.name = "张三";s1.age = 18;s1.sex = "男";s1.chinese = 100;s1.math = 45;System.out.println(s1.name + " " + s1.age + " " + s1.sex);s1.sum();   s1.avg();       Student s2 = new Student();     // 创建Student对象s2.name = "李四"; s2.age = 19;s2.sex = "女";s2.chinese = 87;s2.math = 100;System.out.println(s2.name + " " + s2.age + " " + s2.sex);s2.sum();s2.avg();}
}

类的基本用法 - 构造器

构造器是一种特殊方法，不能写返回值类型，名称必须和类名相同

例如：类名为Student，那么定义的构造器必须也为Student

构造器的应用场景：创建对象时，同时完成对对象成员变量(属性)的初始化赋值。

// 构造器的特点：
// 1. 构造器的名称必须与类名相同
// 2. 构造器没有返回值类型（包括也不能写void）
// 3. 构造器可以重载，可以定义多个
// 4. 创建对象时自动调用构造器
// 5. 类默认自带一个无参构造器，默认调用
// 6. 如果定义了有参构造器，那么默认的无参构造器就没了，若想用无参构造器，就需要自己定义一个无参构造器
public class Student {String name;    // 姓名int age;        // 年龄char sex;        // 性别// 构造器：无参构造器public Student() {System.out.println("无参构造器被调用了！！！");}// 构造器：有参构造器public Student(String n, int a, char s) {System.out.println("有参构造器（完整）被调用了！！！");name = n;age = a;sex = s;}// 构造器：有参构造器public Student(String n){name = n;System.out.println("有参构造器（部分）被调用了！！！");}
}

public class Test1 {public static void main(String[] args) {Student s1 = new Student("张三", 18, '男');Student s2 = new Student();Student s3 = new Student("李四");}
}// 输出如下：
// 有参构造器（完整）被调用了！！！
// 无参构造器被调用了！！！
// 有参构造器（部分）被调用了！！！

类的基本用法 - this

类的基本用法 - 封装

面向对象编程的3大特征：封装、继承、多态

类就是一种封装

封装的设计思想：合理隐藏、合理暴露

类的基本用法 - Javabean

实体类：一种特殊类。必须满足以下

类中成员变量全部私有，并提供public修饰的getter/setter方法
类中必须有一个无参构造器。有参构造器可选

// 以下是一个标准的实体类：
public class Student {// 封装的思想：将属性私有化（provite），通过方法访问属性// 1.属性私有化。作用：封装属性，避免属性被修改private String name;private int age;private char sex;private double chinese;private double math;// 2.提供getter和setter方法。// set：设置属性值// get：获取属性值public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public char getSex() {return sex;}public void setSex(char sex) {this.sex = sex;}public double getChinese() {return chinese;}public void setChinese(double chinese) {this.chinese = chinese;}public double getMath() {return math;}public void setMath(double math) {this.math = math;}// 提供一个无参构造器public Student() {}// 提供一个有参构造器（可选）public Student(String name, int age, char sex, double chinese, double math) {this.name = name;this.age = age;this.sex = sex;this.chinese = chinese;this.math = math;}
}

实体类的应用场景：
实体类的对象只负责数据存取，而对数据的业务处理交给其他类的对象来完成，以实现数据和数据业务处理相分离。

类的基本用法 - static

面向对象 - 继承 extends

继承 - 基础

子类能继承父类的 非私有成员（成员变量、成员方法）。

子类对象的创建由子类、父类共同完成。

使用继承的好处：减少重复代码的编写，提高了代码的复用性。

权限修饰符

权限修饰符：用来限制类中的（成员变量、成员方法、构造器…）能被访问的范围。

	限制能被访问的范围
private	本类
缺省	本类、同一包下的类
protected	本类、同一包下的类、子孙类
public	任意范围

继承 - 进阶

Java是单继承的，类不支持多继承，但支持多层继承。

面试题：为什么类不支持多继承？反证法：假设A类和B类有同名的方法（但功能不同），则会起冲突

object类：java所有类的祖宗类。任何一个类，都是object的子类或子孙类。

方法重写

当父类的某方法不能满足子类的需求时，子类可以重写一个方法名、参数列表相同的方法，这就是方法重写。

注：重写后，Java会遵循就近原则来访问方法。

// 方法重写的注意事项
// 1. 重写方法时，加上@Override注解，他可以指定java编译器，检查方法重写的格式是否正确，代码可读性也更好。
// 2. 子类重写父类方法时，访问权限必须大于或等于父类该方法的权限
// 3. 重写方法的返回值类型，要与原方法相同，或范围更小。
// 4. 私有方法、静态方法不能重写，重写会报错。
public class ChongXie02 {public static void main(String[] args) {Dog d1 = new Dog();d1.shout(); // 输出: 汪汪汪！！！}
}class Dog extends Animal{// 重写Animal父类中的 shout 方法@Overridepublic void shout(){System.out.println("汪汪汪！！！");}
}class Animal{// 叫声的方法public void shout(){System.out.println("动物会叫~~");}
}

方法重写 - 拓展：重写object类的tostring方法

public class ChongXie01 {public static void main(String[] args) {Student s1 = new Student("刘思", 18, '女');System.out.println(s1); // 输出：com.HAF.JiCheng.Student@1b6d3586// 直接输出对象时，默认调用OBject父类的toString方法(可以省略不写调用toString的代码)，返回对象的地址信息// System.out.println(s1.toString);// 输出对象的地址实际上没有意义，开发中更希望输出对象的内容信息，所以子类要重写0bject的toString方法，}
}class Student {String name;int age;char sex;// 重写toString方法@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", sex=" + sex +'}';}// 生成get、set方法public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public char getSex() {return sex;}public void setSex(char sex) {this.sex = sex;}// 无参构造器public Student() {}// 全参构造器public Student(String name, int age, char sex) {this.name = name;this.age = age;this.sex = sex;}
}

子类中访问其他成员的特点

在子类方法中访问其他成员（成员变量、成员方法）：依照就近原则。

先子类局部范围找。然后子类成员范围找。然后父类成员范围找，仍没有找到则报错。

如果子类和父类，出现重名成员，会优先用子类的，若此时要在子类中使用父类的怎么办？

可以通过super关键字，指定访问父类的成员：super.父类成员变量/父类成员方法

public class JiCheng01 {public static void main(String[] args) {Student1 s1 = new Student1();s1.show();}
}class People{String name = "父类";
}class Student1 extends People{String name = "子类";public void show(){String name = "局部变量";System.out.println(name);       // 输出：局部变量System.out.println(this.name);  // 输出：子类System.out.println(super.name); // 输出：父类// this.name：表示当前对象的成员变量// super.name：表示父类的成员变量}
}

面向对象 - 多态

多态 - 基础

final

final：最终。可以修饰 类、方法、变量

final 修饰类：该类称为最终类。特点：不能被继承。
final 修饰方法：该方法称为最终方法。特点：不能被重写。
final 修饰变量：该变量只能赋值一次。
final 修饰基本类型的变量，变量存储的数据不能改变。
final 修饰引用类型的变量，变量存储的地址不能改变，但地址所指向对象的内容可以改变

抽象类 abstract

abstract：抽象。可以修饰 类、方法

abstract 修饰类：该类称为抽象类。
abstract 修饰方法：该类称为抽象方法。

抽象类的特点

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
类该有的成员（成员变量、方法、构造器），抽象类也可以有。
抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
一个类继承抽象类，必须重写抽象类的全部抽象方法，否则这个类也必须定义成抽象类。