构造器、方法重载、继承、方法重写、自动转型、多态课堂笔记

构造器（构造方法）：

定义格式：public 类名(){}

方法的定义格式：public  返回类型 方法名(参数){}

作用：1、用来构造对象

            2、用来初始化属性

例：public teacher(){}

构造方法的调用：

//创建对象，调用构造方法

Teacher tea = new Teacher("李四");
Teacher tea1 = new Teacher();
tea.name = "张三";
tea1.name = "李四";
tea = tea1;        //tea1将地址赋给了tea,tea和tea1指向同一个地址单元
tea1.name = "王五";
System.out.println(tea.name);
System.out.println(tea1.name);

结果为：王五

                王五

方法重载 ：

定义：同一个类中，多个方法的方法名相同，参数不同(类型、个数、顺序)的方法互为重载方法

作用：给同一个行为提供不同的执行过程

例：

1、public void student(){}
2、public void student(string name){}
3、public void student(int age){}
4、public void student(string name,int age){}
5、public void student(int age,string name){}

构造方法也可以重载

</pre></p><pre name="code" class="java">

1、public Teacher(){
	System.out.println("执行了老师类的构造方法");
	}
2、public Teacher(String n){
        name = n;
        System.out.println(name);
	}

调用时

public class Test {
	public static void main(String[] args) {
        Teacher tea = new Teacher();
        1、tea.Teacher();    //第一种方式输出   <span style="font-family: Arial, Helvetica, sans-serif;">执行了老师类的构造方法</span>

        2、tea.Teacher("张三");  <span style="font-family: Arial, Helvetica, sans-serif;">//第二种方式输出    张三</span>

}

类继承 ：

定义：子类继承父类的所有的非私有属性和方法
格式 ： public class 子类名  extends  父类名{}

当子类具有父类中的某些相同的属性时，为避免繁琐，用继承来实现

//定义一个父类：
public class Student{
  public int age;
  public String name;
  public void study(){}
 }
//子类大学生UnStudent也有父类中同样的属性，此时继承父类Student
public class UnStudent <strong>extends</strong> Student{}

UnStudent us = new UnStudent();  us.study();            //此时用us调用Student类中的方法时就会出现一样的结果

方法重写：

定义：子类继承父类的前提，然后子类定义一个和父类相同的（方法名、参数、返回类型）方法

当父类中的某些方法在子类中不适用时，我们需要对方法进行重写来替代原来的方法。

例：

父类：

Public class Student{
Public void study(){
   System.out.println("学生学习");
}
}

子类：

Public class UnStudent extends Student{
Public void study(){
   System.out.println(“大学生学习”);
}
}

此时在主函数中调用study方法：

public static void main(String[] args) {
Student stu = new Student();
Stu.study();
}

输出的结果为：“大学生学习”。

如果不进行方法重写，子类直接从父类继承方法study，则输出结果为：“学生学习”。

 

*区别于方法重载

构造函数是不能被继承，所以也不存在构造函数重写，但是构造方法能够进行方法重载

 

自动转型：

一、定义：创建子类的对象，然后自动转型为父类的类型

格式：父类类名  对象名  = new  子类类名();

例：

Teacher tea = new UnTeacher();        此时tea就是Teacher类型

二、！注意：

*如果有自动转型，转型后的对象类型为转型后的类型：

1、如果子类重写了父类的方法则执行的是重写后的；

2、如果没有重写，则执行的是父类自己的

*如果没有自动转型过程：

1、则执行的方法都是自己的方法

例：

区分：

UnStudent us = new UnStudent();//没有自动转型
Student us1 = new UnStudent();//自动转型且重写了方法
Student us2 = new Student();//没有自动转型

主函数中调用

us.study();
us1.study();
us2.study();

Student、UnStudent类中代码同上

输出结果为：

大学生学习

大学生学习

学生学习

 

三、如果在UnStudent类中写一个自己的方法

例如

public class UnStudent extends Student{
public void study(){
System.out.println("大学生的学习方法");
}
public void playGame(){
System.out.println("大学生玩dota");//不是从父类中继承过来的
}
}

此时再调用

us.playGame();
us1.playGame();
us2.playGame();

第二种和第三种情况会报错，因为此时的父类对象没有访问权限，不能调用子类中的方法

多态：

Java三大特性 （面向对象的核心）：封装性   继承性   多态性

体现：多个同一种类型的对象，执行同一个方法，执行的过程不一样(有区别)

 

为什么会有多态现象？

1、自动转型+方法重写     

2、自动转型+方法重写的前提--继承

方法分类（构造方法、普通方法、抽象方法）和类的分类（普通类、抽象类、接口）：

一、 

构造方法：public 类名(){}

普通方法：public 返回类型  方法名(参数){}

抽象方法：public abstract 返回类型 方法名(参数);  //没有过程的方法

 

二、

普通类（相当于编码人员）：public class 类名{}

 1.只能有普通方法和构造方法，一定不能有抽象方法

//如果一个普通类继承一个有抽象函数的抽象类或者接口，应该要重写父类所有的抽象方法

 2.可以创建对象

 3.属性可以是常量（static final），也可以是变量

//定义常量的方法：

public static final String name = “ququ” //常量一定有一个值

抽象类（相当于小组长，起到一个过渡作用）：public abstract class 类名{}

 1.三种类型的方法都可以存在

 2.不能创建对象

 3.属性可以是常量（static final），也可以是变量

接口（相当于项目经理，只指导不做事）：public interface 类名(){}

 1.只能有抽象方法，普通方法和构造方法不存在

 2.不能创建对象

 3.属性一定是常量（static final）

三、三种不同类的相互继承

普通类可以继承抽象类和接口

抽象类可以继承接口

反过来则不一定

接口继承：
接口和抽象类的作用是用来当父类被继承的，抽象方法是用来指导子类重写(实现)的
关键字：implements 
格式：public class 子类类名  implements 接口名{
//重写父类的所有的抽象方法
}
接口无非就是领导，只是指导开发

附：规范画板

package com.huaxin.lesson0305.project;

import java.awt.event.MouseListener;

import javax.swing.JFrame;

/**
 * 画板项目实战
 * 
 * this代表当前类的对象
 * 方法：this一定是在方法里面才能用
 * 	   看this在哪个方法中使用的，然后寻找调用当前方法的对象，那this==调用当前方法的对象
 * @author fgg
 *
 */
public class DrawBoard extends JFrame{
	//局部变量 全局变量
	public static void main(String[] args) {
		DrawBoard db = new DrawBoard();
		db.initFrame();
	}
	/**
	 * 初始化窗体
	 * this == db;
	 */
	public void initFrame(){
		this.setSize(500, 500);
		this.setDefaultCloseOperation(3);
		this.setVisible(true);
		//创建监听器的实现子类对象来代替创建接口对象
		DrawListener dl = new DrawListener();
		//把监听器添加到窗体上
		this.addMouseListener(dl);
		
	}
}

package com.huaxin.lesson0305.project;

import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

public class DrawListener implements MouseListener{
	public void mouseClicked(MouseEvent e) {
		
	}
	public void mousePressed(MouseEvent e) {
		
	}
	public void mouseReleased(MouseEvent e) {
		
	}
	public void mouseEntered(MouseEvent e) {
		
	}
	public void mouseExited(MouseEvent e) {
		
	}
}