java视频学习笔记-3-（面向对象，封装，构造方法，static，说明书，帮助文档，代码块，继承，重写，猫狗案例）

1. 面向对象

特征：封装，继承，多态

类与对象的关系
类：是一组相关的属性和行为的集合是一个抽象的概念。
对象：是该类事物的具体表现形式，具体存在的个体。
定义一个类，就是定义该类的成员变量、成员方法以及构造方法。

成员变量和局部变量的区别：
（1）在类中的位置不同：成员变量在类中方法外，局部变量在方法定义或者方法声明上
（2）在内存中的位置不同：成员变量在堆内存，局部变量在栈内存
（3）生命周期不同：成员变量随着对象的创建而存在，随着对象的消失而消失。 局部变量随着方法的调用而存在，随着方法的调用完毕而消失
（4）初始化值不同：成员变量有默认初始值，局部变量没有默认初始值，必须定义，赋值才能使用
注：成员变量和局部变量名称可以一样，在方法中使用的时候，采取的是就近原则

匿名对象：没有名字的对象

public static void main(String[] args){
    Student s = new Student();
    s.show()
    s.show()
    //匿名对象
    new Student().show();
    new Student().show(); //这里其实是重新创建了一个对象
}

匿名对象的应用场景：
（1）调用方法，仅仅只调用一次的时候。好处：匿名对象调用完毕就是垃圾，可以被垃圾回收器回收。
（2）匿名对象可以作为实际参数传递 

2. 封装

封装概述：隐藏对象的属性和实现细节，仅对外提供公共访问方式
好处：隐藏实现细节，提供公共的访问方式；提高了代码的复用性；提高安全性
封装原则：将不需要对外提供的内容都隐藏起来；把属性隐藏，提供公共方法对其进行访问

private关键字是一个权限修饰符，被private修饰的成员只能在本类中访问，常常修饰成员变量
this代表当前类的对象引用吗，即代表当前类的一个对象 （谁调用这个方法，在该方法内部的this就代表谁）  

class Student{
    private String name;
    private int age;

    public Student(); //构造方法

    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
}

3. 构造方法

作用：给对象的数据进行初始化
格式：方法名与类名相同；没有返回值类型，连void都没有，没有具体的返回值

注意事项：
（1）如果没有给出构造方法，系统将自动提供一个无参构造方法。
（2）如果我们给出了，系统就不再提供默认的无参构造方法。
（3）构造函数的重载即是不同的参数类型
给成员变量赋值的两种方式：
（1）setXxx()
（2）构造方法

以后应用时，有构造方法就创建对象，没有的话可能成员都是静态的

 4. static

static可以修饰成员变量和成员方法，如果某个成员变量是被所有对象所共享的，那么他就应该定义为静态的
特点：
（1）随着类的加载而加载
（2）优先于对象存在
（3）被类的所有对象共享
（4）可以通过类名调用，其实也可以通过对象名调用，推荐用类名调用
注意事项：
（1）在静态方法中没有this关键字。因为静态时随着类的加载而加载，this是随着对象的创建而存在，静态比对象先存在
（2）静态方法只能访问静态的成员变量和静态的成员方法

静态变量和成员变量的区别：
（1）静态变量属于类，成员变量属于对象
（2）内存中的位置不同，静态变量在方法区的静态区内，成员变量存储于堆内存
（3）内存出现时间不同，静态随着类，成员随着对象
（4）调用不同，成员变量只能通过对象名调用

main方法的格式详解：
（1）public：公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大
（2）static：静态的，不需要创建对象，通过类名就可以，方便jvm的调用
（3）void：内容返回给jvm没有意义
（4）main：一个常见的方法入口
（5）String[] args：一个字符串数组，早期为了接收键盘录入的数据

5. 制作一个说明书

（1）写一个工具类
（2）对这个类加入文档注释
（3）用工具解析文档注释    javadoc工具    格式： javadoc -d 目录 -author -version ArrayTool.java

6. 如何使用一个帮助文档

（1）打开帮助文档
（2）点击索引，找到输入框
（3）在输入框中找到想了解的内容
（4）看包：java.lang包下的类不需要导入，其他的全部需要导入
（5）看看类的解释和说明，别忘了看看该类的版本
（6）看类的结构：成员变量，构造方法，成员方法
（7）学习构造方法：有构造方法的就创建对象，没有的表明所有的成员都是静态的
（8）看成员方法，如果是静态，可以通过类名调用

7 代码块

执行顺序：静态代码块--构造代码块--构造方法

class Code{
    //构造代码块：在类中的成员位置，多个构造方法中的相同的代码存放到一起，
    //每次调用和构造都执行，并且在构造方法前执行，一般对对象进行初始化
    {
        int x=100;
        System.out.println(x);
    }    
    //在类中的成员位置，用{}括起来的代码，只不过用static进行了修饰
    //一般对类进行初始化，只执行一次
    static {
        int a=1000;
        System.out.println(a)
    }
    public Code(){}
}

class CodeDemo(){
    public static void main(String[] args){
        //局部代码块，用于限定变量的周期
        {
            int x=10;        
        }
            
    }
}

8. 继承

概述：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类只要继承那个类即可
格式：通过extends关键字可以实现类与类的继承   class 子类名 extends 父类名 {}
单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类
好处：
（1）提高了代码的复用性
（2）提高了代码的维护性（如果需要修改，只需要修改一处）
（3）让类与类之间产生了关系，是多态的前提（弊端：类的耦合性很强）
开发的原则：低耦合（耦合为类与类的关系），高内聚（内聚为自己完成某件事的能力）

特点：
（1）只支持单继承，不支持多继承   多继承格式：extends 类1，类2，...
（2）java支持多层继承，形成继承体系 

注意事项：
（1）子类只能继承父类所有非私有的成员（方法和变量）
（2）子类不能继承父类的构造方法，但可以通过super关键字去访问父类构造方法
（3）不要为了部分功能去继承
（4）子类中所有的构造方法默认都会访问父类中空参数的构造方法（子类每一个构造方法的第一条默认语句都是super()）
（5）如果父类没有无参构造函数，那么可以通过super()去调用父类的
（6）如果子类中的方法和父类中的方法声明一样，则调用子类的

使用继承的情况：两个类A,B，知道满足关系“is a”，那么就可以考虑使用

this和super的区别：this代表对本类的引用；super代表父类存储空间的标识（可以理解为父类引用，可以操作父类的成员）
在构造的时候，this和super必须出现在第一条语句

9. 方法重写 

重写：子类中出现了和父类中一模一样的方法声明
方法重写与重载的区别：重写是子类和父类，重载是本类，能改变返回值类型
应用：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，既沿袭了父类的功能，又定             义了子类特有的功能

class Phone {
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}
}

class NewPhone extends Phone {
	public void call(String name) {
		System.out.println("给"+name+"打电话"); //或者super.call(name)
		System.out.println("可以听天气预报了");
	}
}

public class ExtendsDemo {
	public static void main(String[] args) {
		NewPhone np = new NewPhone();
		np.call("帅哥");
	}
}

方法重写的注意事项：
（1）父类中的私有方法不能被重写
（2）子类重写父类方法时，访问权限不能更低，最好一致
（3）父类静态方法，子类也必须通过静态方法进行重写

10. 猫狗案例

//定义动物类
class Animal {
	private String name;
	private int age;
	private String color;
	
	//无参构造函数
	public Animal() {}
	//有参构造函数
	public Animal(String name,int age,String color) {
		this.name = name;
		this.age = age;
		this.color = color;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
		
	public void setColor(String color) {
		this.color = color;
	}
	
	public String getColor() {
		return color;
	}
	
	public int getAge() {
		return age;
	}
	
	public String getName() {
		return name;
	}
	
	public void eat() {
		System.out.println("该吃饭了")
	}
}

//定义猫类
class Cat extends Animal{
	public Cat() {}
	
	public Cat(String name,int age, String color) {
		super(name,age,color);
	}
	
	public void playGame() {
		System.out.println("玩耍");
	}
}

//定义狗类
class Dog extends Animal{
	public Dog() {}
	
	public Dog(String name,int age, String color) {
		super(name,age,color);
	}
	
	public void lookDoor() {
		System.out.println("看门");
	}
}

class ExtendsDemo{
	public static void main(String[] args) {
		//第一种方式
		Cat c1 = new Cat();
		c1.setColor("白色");
		c1.setAge(6);
		c1.setName("大花");
		System.out.println(c1.getName()+"--"+c1.getAge()+"--"+c1.getColor());
		//第二种方式
		Cat c2 = new Cat("杰瑞",12,"土豪金");
		System.out.println(c2.getName()+"--"+c2.getAge()+"--"+c2.getColor());
		
		Dog d1 = new Dog();
		d1.lookDoor();
	}
}