Java复习之路（第七天 面向对象）（ this关键字继承 ）

Java基础

面向对象：

定义：构造方法是一种特殊的方法，它的方法名与类同名。对象的创建就是通过构造方法来完成，他的主要的功能就是完成独享的重建或者是对象的初始化，当类实例化一个对象时就会自动的调用构造的方法，构造的方法和其他的方法一样可以重载

形式：方法名和类名完全一致

可以有参数，也可以没有参数

修饰符 类名（[参数]）{

    代码。。。

} 

class Person{
		//构造方法
		public void Person() {
			
	} 
}

创建并且调用构造方法，并实现构造方法的重载

package com.tedu.constructor;
//构造构造方法创建对象
public class Test1_Constructor {
	public static void main(String[] args) {
		 //测试Person对象
		//在执行new Person（）方法是自动的进行调用构造方法
		
		//在调用方法的时候可以做到自动的进行匹配相应的参数的函数
		Person person=new Person();
		Person person2=new Person(2);
		Person person3=new Person("txs");
	}
}

//创建人类
class Person{
		//构造方法,方法名称和类名完全一样，修饰符号，方法名（[参数]）
		//作用1;用来创建对象，作用2.初始化对象
		public  Person() {
		System.out.println(1);
	} 
		//重载构造方法
		public  Person(int a) {
			System.out.println(a+15);
		} 
		
		public  Person(String name) {
			System.out.println(name);
		} 
}

方法总结：

1.方法名和类名一致

2.常用于创建对象，初始化对象

3.在new Person（）的时候，会自动调用无参构造函数

4.当提供一个含参数构造是，无参构造会被覆盖，如果还想要new Person（）这样创建对象，需要手动的吧无参数的构造方法写出来比如Public Person(){ }

5.一般情况下，都会手动的进行提供无参数构造

 

构造方法的赋值

package com.tedu.constructor;
//构造方法的赋值
public class Test2_Constructor2 {
	public static void main(String[] args) {
		Student student=new Student("柳市", 12);
		System.out.println(student.age);
		System.out.println(student.name);
	}	
}

//创建一个学生类
class Student{
	String name ;
	int age;
	//赋值方式一：利用set方法
	//赋值方式二：利用构造函数
	public Student() {}//方便new Student（）创建对象
	public  Student(String n,int a) {
		name=n;
		age=a;	
	}
}

运行的过程：

this

定义：this代表本类对象的一个引用的对象

形式：

name=name

age=age

public  Teacher(int no,String name) {
		name=name;     //结果是null
		no=no;         //结果是0
	}
//总结：违背了程序的就近的原则


更改以后得代码：
	public  Teacher(int no,String name) {
		this.name=name;
		this.no=no;
	}

知识总结：当局部变量的名称和成员的变量名称相同时，可以通过this的关键字进行调用成员的变量，进而给成员变量进行赋值，否则，根据变量的就近的原则，会一直使用局部的变量

知识点：有参构造和无参构造可以通过this这个关键字进行相互调用但是不可以同时调用

有参数进行调用无参数

public  Car(String name) {
        //通过this调用含参构造
        this();
        //this.name代表的是成员的变量，右面的name代表的是局部变量 
        this.name=name;
    }

无参数进行调用有参数

    public  Car() {
        //这里面this函数调用的是下面的有参数的函数
        //通过this调用含参构造
        this("BWM");
        System.out.println(1);
    }

package com.tedu.constructor;
//测试this在构造方法里面的调用
public class Test4_this2 {
	public static void main(String[] args) {
		Car car2=new Car();
		System.out.println(car2.name);
		Car car=new Car("宝马");
		System.out.println(car.name);
	}
}

//创建汽车类
class  Car{
	String name;
	public  Car() {
		//这里面this函数调用的是下面的有参数的函数
		//通过this调用含参构造
		this("BWM");
		System.out.println(1);
	}
	public  Car(String name) {
		//通过this调用含参构造
		this();
		//this.name代表的是成员的变量，右面的name代表的是局部变量 
		this.name=name;
	}
	
}

方法的过程：

this._本类对象的成员,包括成员变量和成员的方法，this必须要放在方法第一条语句出现（在第二类）

 

构造代码块和局部代码块

构造代码块

1.在类的内部，方法外部的代码块

2.通常用于抽取构造方法是中的共性的代码

3.每次调用构造方法前都会调用构造代码块

4.优先于构造方法加载，每次创建对象的时候都会进行创建

package com.tedu.block;
//测试代码块（构造代码块(构造函数)/局部代码块）
public class Test5_Block {
	public static void main(String[] args) {
		//创建Animal对象
		//1.如果有构造的方法代码块，优先执行鼓噪代码块后执行构造的方法
		Animal animal=new Animal();
		Animal anima2=new Animal();
		//Animal animal1=new Animal("猴子",3);
		//System.out.println(animal1.age);
		//System.out.println(animal1.name);
	}
}
class Animal{
	/*
	 * 构造代码块
	 */
	{
		System.out.println(1);
	}
	//无参数构造方法
	String name;
	int age;
	public  Animal(){
		System.out.println(2);
	}
	//无参数构造方法
	public  Animal(String name,int age){
		this.age=age;
		this.name=name;
	}
	
}

局部代码块

1.在方法里面的代码块

2.通常用于控制变量的作用的范围，出了括号就会失效

3.b变量的范围越小越好，成员变量会有线程安全的问题

4.他们的执行的顺序并没有固定的顺序的说明

构造的方法，在执行的构造的方法前会把所有的构造代码块执行完

package com.tedu.constructor;
//测试局部的代码块
public class Test6_Block2 {
	public static void main(String[] args) {
		Zoo zoo=new Zoo();
		zoo.show();
	}
}

class Zoo{
        //构造的方法，在执行的构造的方法前会把所有的构造代码块执行完
        public Zoo(){
            System.out.println("0")
        }
	//构造代码块
	{
		System.out.println("3");
	}
	public void show() {
		//局部的代码块
		{
			System.out.println(1);
		}
		System.out.println(2);
	}
		//构造代码块
		{
			System.out.println("4");
		}
}

他们的执行的顺序与他们的方法所在的位置无关，取决于他们的方法的优先级别

继承：

定义：

继承是面向对象最显著的一个特性，继承是从已有的类中派生出了新的类，新的类能吸收已有的数据属性和行为，并扩展新的能力。Java继承是使用已存在类的定义作为基础建立新类技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但是不能选择性的继承父类（超类，基类),这种技术使得复用以前的代码非常容易，能够大大的进行缩短开发周期，降低开发的费用

继承的特点：

1.使用extends关键字

2.相当于子类把父类的功能进行复制一份

3.Java仅仅支持单继承

4.继承具有传递的关系（爷爷，儿子，孙子）

5.不可以继承父类的私有的成员

6.继承多用功能的修改，子类尽心拥有父类的功能的同时进行功能的拓展

7.像是is a 的关系

入门的案例：

package com.tedu.extend;
//测试继承的关系
public class Test7_Extends {
	public static void main(String[] args) {
		//创建的子类的对象
		Son son=new Son();
		//进行调用父类的方法属性
		son.language="英语";
		son.skin="黄";
		//将方法的值进行调用
		System.out.println(son.language);
		System.out.println(son.skin);
		son.eat();
	}
}
//创建父类
class Fu{
	String  skin;
	String language;
	public void eat() {
		System.out.println("吃饭");
	}
}
class Son extends Fu{
    //继承的含义就相当于子类将父类的内容进行复制了一下
}
class Sun extends Son{
    //继承的含义就相当于孙子将爸爸的内容进行复制了一下
}