Java面向对象三大特性
封装
1. 封装概述
利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体。 数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节， 只保留一些对外接口使之与外部发生联系。用户无需知道对象内部的细节， 但可以通过对象对外提供的接口来访问该对象。
2. 优点
减少耦合：可以独立地开发、测试、优化、使用、理解和修改
减轻维护的负担：可以更容易被程序员理解，并且在调试的时候可以不影响其他模块
有效地调节性能：可以通过剖析确定哪些模块影响了系统的性能
提高软件的可重用性
降低了构建大型系统的风险：即使整个系统不可用，但是这些独立的模块却有可能是可用的
3. 成员变量和局部变量的区别
区别成员变量局部变量在类中位置不同类中方法外方法内或者方法声明上在内存中位置不同堆内存栈内存声明周期不同随着对象存在而存在，随着对象消失而消失随着方法调用而存在，随着方法调用完毕而消失初始化值不同有默认的初始值没有默认的初始值，必须先定义，赋值，才能使用
注意：局部变量名可以和成员变量名一样，在方法中使用的时候，采用就近原则。
4. 类的初始化过程
以Student类为例：
public class Student {
private String name;
private int age;
public Student() {
}
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;
}
}
Student s=new Student();
具体步骤：
1.加载Student.class文件进内存
2.在栈内存为s开辟空间
3.在堆内存为学生对象开辟空间
4.对学生成员变量进行默认初始化
5.对学生成员变量进行显示初始化
6.通过构造方法对学生对象的成员赋值
7.学生成员对象初始化完毕，将对象地址赋值给s变量。
封装:一个标准的手机类的代码及测试
手机类
public class SmartPhone {
private String brand;
private double price;
private String color;
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void call(String name){
System.out.println("打电话给"+name);
}
public void sendMessage(String name){
System.out.println("给"+name+"发短信");
}
public void playGame(){
System.out.println("玩游戏");
}
}
手机测试类1
public class SmartPhoneDemo {
public static void main(String[] args) {
SmartPhone sp=new SmartPhone();
sp.setBrand("IPhone");
sp.setPrice(6666);
sp.setColor("白色");
System.out.println("使用"+sp.getBrand()+"牌、售价为"+sp.getPrice()+"元的"
+sp.getColor()+"的手机");
sp.call("Jobs");
sp.sendMessage("Kuke");
sp.playGame();
}
}
一个手机对象的内存简图：
手机测试类2
public class SmartPhoneDemo2 {
public static void main(String[] args) {
SmartPhone sp=new SmartPhone();
sp.setBrand("IPhone");
sp.setPrice(6666);
sp.setColor("白色");
System.out.println("使用"+sp.getBrand()+"牌、售价为"+sp.getPrice()+"元的"
+sp.getColor()+"的手机");
sp.call("Jobs");
sp.sendMessage("Kuke");
sp.playGame();
SmartPhone sp2=new SmartPhone();
sp2.setBrand("小米");
sp2.setPrice(1000);
sp2.setColor("黑色");
SmartPhone sp3=sp;
sp.setPrice(3555);
System.out.println("使用"+sp.getBrand()+"牌、售价为"+sp.getPrice()+"元的"
+sp.getColor()+"的手机");
}
}
多个手机对象的内存简图：
5. 静态变量和成员变量的区别
6. 代码块
静态代码块：在类加载的时候就执行，且执行一次。一般用于对对象进行初始化。
构造代码块：每次调用构造方法都执行且在构造方法之前执行。一般是对类进行初始化。
执行顺序：
静态代码块---构造代码块---构造方法
public class CodeBlock {
//构造方法
CodeBlock(){
int a=10;
System.out.println(a);
}
//构造代码块
{
int a=100;
System.out.println(a);
}
//静态代码块
static {
int a=1000;
System.out.println(a);
}
public static void main(String[] args) {
CodeBlock codeBlock=new CodeBlock();
}
}
输出结果：
1000
100
10
继承
1. 继承概述
继承实现了 IS-A 关系，例如 Cat 和 Animal 就是一种 IS-A 关系，因此 Cat 可以继承自 Animal，从而获得 Animal 非 private 的属性和方法。
继承应该遵循里氏替换原则，子类对象必须能够替换掉所有父类对象。
Cat 可以当做 Animal 来使用，也就是说可以使用 Animal 引用 Cat 对象。父类引用指向子类对象称为 向上转型 。
Animal animal = new Cat();
2. 优点
提高了代码的复用性
提高了代码的维护性
在类与之间产生了关系，是多态的前提
3. Java中继承特点
Java只支持单继承，不支持多继承
Java支持多层继承
4. Java中继承注意事项
子类只能只能继承父类所有非私有成员（成员方法和成员变量）
子类不能继承父类的构造方法，但是可以通过super关键在去访问父类构造方法
不要为了部分功能而去继承
继承中类之间体现的是“is a”的关系。
5. 继承中成员变量的关系
子类中成员变量和父类中成员变量名称不同。
子类中成员变量和父类中成员变量名称相同。
在子类方法中的查找顺序：
在子类方法的局部范围找，有就使用
在子类的成员范围找，有就使用
在父类的成员范围找，有就使用
如果还找不到，就报错
6. 继承中构造方法的关系
子类中所有的构造方法默认会都会访问父类中空参数的构造方法
原因：因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前， 一定要完成父类数据的初始化。
每一个子类的构造方法第一条语句默认是：super();
如果父类中没有无参构造方法，该怎么办呢？
方式一：子类通过super去显示调用父类其他的带参的构造方法
方式二：子类通过this去调用本类的其他构造方法 （子类一定要有一个去访问父类的构造方法，否则父类数据就没有初始化）
/**
* 1. 子类中所有的构造方法默认会都会访问父类中空参数的构造方法
* 2. 每一个子类的构造方法第一条语句默认是：super()
*/
class Father{
public Father() {
System.out.println("Father的无参构造函数");
}
}
class Son extends Father{
public Son() {
//super();
System.out.println("Son的无参构造函数");
}
public Son(String name) {
//super();
System.out.println("Son的带参构造函数");
}
}
public class InheritanceDemo {
public static void main(String[] args) {
//使用无参构造函数初始化
Son son=new Son();
System.out.println("===========");
//使用带参构造函数初始化
Son son2=new Son("林青霞");
}
}
输出结果：
Father的无参构造函数
Son的无参构造函数
===========
Father的无参构造函数
Son的带参构造函数
/**
* 3. 如果父类中没有无参构造方法，该怎么办呢？
方式一：子类通过super去显示调用父类其他的带参的构造方法
方式二：子类通过this去调用本类的其他构造方法
（子类一定要有一个去访问父类的构造方法，否则父类数据就没有初始化）
*/
class Parent{
public Parent(String name){
System.out.println("Parent的带参构造函数");
}
}
class Child extends Parent{
public Child() {
//子类通过super去显示调用父类其他的带参的构造方法
super("林青霞");
System.out.println("Child的无参构造函数");
}
public Child(String name) {
//方式一：子类通过super去显示调用父类其他的带参的构造方法
//super(name);
//方式二：子类通过this去调用本类的其他构造方法
this();//嗲用Child()的无参构造函数
System.out.println("Child的带参构造函数");
}
}
public class InheritanceDemo2 {
public static void main(String[] args) {
Child c = new Child();
System.out.println("==============");
Child c2 = new Child("林青霞");
}
}
输出结果：
Parent的带参构造函数
Child的无参构造函数
==============
Parent的带参构造函数
Child的无参构造函数
Child的带参构造函数
7.类中成员变量初始化
一个类的成员变量的初始化：
默认初始化
显式初始化
构造方法初始化
子类的初始化（分层初始化）
先进行父类的初始化，再进行子类的初始化
class X{
Y b=new Y(); //显式初始化
X(){
System.out.println("X");
}
}
class Y{
Y(){
System.out.println("Y");
}
}
public class Z extends X{
Y y=new Y();
public Z() {
super();//子类的初始化（分层初始化）:先进行父类的初始化，然后再进行子类的初始化。
System.out.println("Z");
}
public static void main(String[] args) {
new Z();
}
}
输出结果：
Y
X
Y
Z
7. 继承中成员方法的关系
重写（Override）:子类和父类中出现了一模一样的方法声明
注意：
父类中私有成员方法不能被重写（因为父类中私有成员方法不能被继承）
子类重写父类中方法时，访问权限不能更低（最好一致）
父类是静态方法时，子类也必须通过静态方法进行重写。
子类和父类的声明最好一模一样。
8. final关键字
final关键字是最终的意思，可以修饰类，修饰变量，修饰成员方法
修饰类：不能被继承
修饰变量：变量就变成了常量，只能被赋值一次
修饰方法：方法不能被重写
注意：
final修饰局部变量
在方法内部，该变量不可以被改变
在方法声明上，分为基本类型和引用类型的情况
(1)基本类型：是值不能变
(2)引用类型：是地址不能变，但是该对象的堆内存中的值是可以改变的
final修饰变量的初始化时机
在对象构造完毕前即可（非静态常量）,被final修饰的变量只能赋值一次。
继承:一个标准的动物类、猫类、狗类的代码及测试
动物类
class Animal{
private String name;
private int age;
private String color;
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 String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void eat(){
System.out.print("吃什么东西？");
}
}
猫类
class Cat extends Animal{
@Override
public void eat() {
super.eat();
System.out.println("猫粮");
}
public void play(){
System.out.println("小猫在玩耍");
}
}
狗类
class Dog extends Animal{
@Override
public void eat() {
super.eat();
System.out.println("狗粮");
}
public void bark(){
System.out.println("小狗汪汪叫");
}
}
测试
public class AnimalDemo {
public static void main(String[] args) {
Dog dog=new Dog();
dog.setName("旺财");
dog.setAge(12);
dog.setColor("黄色");
System.out.println(dog.getName()+"\t"+dog.getAge()+"\t"+dog.getColor());
dog.eat();
dog.bark();
Cat cat=new Cat();
cat.setName("汤姆");
cat.setAge(12);
cat.setColor("蓝色");
System.out.println(cat.getName()+"\t"+cat.getAge()+"\t"+cat.getColor());
cat.eat();
cat.play();
}
}
多态
1. 多态概论
某一个事物，在不同时刻表现出来的不同状态。 具体来讲，就是调用同一方法，会执行不同的功能。
实际生活：水在不同时刻的状态。
2. 多态分类
多态分为编译时多态和运行时多态：
编译时多态主要指方法的重载
运行时多态指程序中定义的对象引用所指向的具体类型在运行期间才确定
3. 运行时多态有三个条件
继承
覆盖（重写）
向上转型
4. 多态的好处和弊端
好处
提高了代码的维护性（由继承保证）
提高了程序的扩展性（由多态保证）
弊端
不能访问子类特有功能（特有方法）
如何访问子类中的特有功能？
方法一：将父类的引用强制转换为子类的引用，即向下转型
方法二：创建子类对象调用方法（可以，但是不合理，并且占内存）
/**
* 对象间的转型问题：
向上转型：
Parent f = new Child();
向下转型：
Child z = (Child)f; //要求该f必须是能够转换为Zi的。(父到子)
*/
class Parent {
public void show() {
System.out.println("show fu");
}
}
class Child extends Parent {
public void show() {
System.out.println("show zi");
}
public void method() {
System.out.println("method zi");
}
}
public class PolymorphismDemo {
public static void main(String[] args) {
Parent fu=new Child();
fu.show();
//fu.method();//不能访问子类特有功能（特有方法）
Child zi=(Child)fu; //向下转型
zi.show();
zi.method();
}
}
输出结果：
show zi
show zi
method zi
class Animal {
public void eat(){}
}
class Dog extends Animal {
public void eat() {}
public void lookDoor() {
}
}
class Cat extends Animal {
public void eat() {
}
public void playGame() {
}
}
public class PolymorphismDemo3 {
public static void main(String[] args) {
//内存中的是狗
Animal a = new Dog();
Dog d = (Dog)a;
//内存中是猫
a = new Cat();
Cat c = (Cat)a;
//内存中是猫
Dog dd = (Dog)a; //ClassCastException
}
}
多态中对象内存图
5. 多态中的一些问题
/**
* 多态中的成员访问特点：
A:成员变量
编译看左边，运行看左边。
B:构造方法
创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
C:成员方法
编译看左边，运行看右边。( 由于成员方法存在方法重写，所以它运行看右边。)
D:静态方法
编译看左边，运行看左边。(静态和类相关，算不上重写，所以，访问还是左边的)
*/
class Fu{
public int num=100;
public void show(){
System.out.println("show function");
}
public static void function(){
System.out.println("function Fu");
}
}
class Zi extends Fu {
public int num = 1000;
public int num2 = 200;
@Override
public void show() {
System.out.println("show Zi");
}
public void method() {
System.out.println("method zi");
}
public static void function() {
System.out.println("function Zi");
}
}
public class PolymorphismDemo2 {
public static void main(String[] args) {
Fu f = new Zi();
System.out.println(f.num);
//System.out.println(f.num2);
f.show();
//找不到符号
//f.method();
f.function();
}
}
输出结果：
100
show Zi
function Fu
