从入门到放弃的第二周（面向对象）......day.9.。。。。。继承，重写，绑定，final；

1，继承

 

使用extends实现继承
父类中哪些成员可以被子类继承？
public成员，protected成员
不能被继承：private修饰的，default修饰的，构造方法

 

 

2，方法重写(override) 覆盖

 

概念：子类中重新实现父类中的方法

1. 方法名一样，
2. 参数列表一样
3. 子类方法的返回值类型应该与父类型一样或是其子类
4. 子类方法的访问控制修饰符其可见访问不能减小，
5. 子类方法声明抛出的异常不能比父类方法声明抛出的异常多

 

3，Object类

 

Object类是所有类的父类，有几个方法一般会被重写
toString():输出或记录日志时会使用到该方法返回的结果
equals():在业务逻辑上判断是否是一个对象时重写
hashCode()；

补充：

==与equals的区别
==:用于基本数据类型之间的比较，布尔类型不能与其他数值类别比较。比较是值
用于引用类型之间的比较，比较的是地址
equals: 只能使用引用类型调用，默认情况下与==一样，不过在实际开发中会重写该方法

 

 

 

1，声明一个实体类Student，属性；name，age，no(学号)，重写equals方法
2，声明一个学生的操作类，有一个方法：
从一个学生数组中，根据姓名和学号判断给定的学生是否存在
3，测试

 

 

public class Student {
           private String name;
           private int  age ;
           private int  no;
		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 int getNo() {
			return no;
		}
		public void setNo(int no) {
			this.no = no;
		}         
}

 

　　

 

 

public class Studentmaker {
  
	 public boolean equals(Student a,Student b){
		
		 if(a.getName().equals(b.getName())){
			 if(a.getNo()==b.getNo()){
				 return true;
			 }else{return false;}		 
		 }		 
		 return false;
	 }
}

　　

public class Sudenttest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		      Studentmaker studentmaker=new Studentmaker();
             Student s1=new Student();
             Student s2=new Student();
             s1.setName("suxiao");
             s1.setAge(21);
             s1.setNo(123);
             s2.setName("suxiao");
             s2.setAge(21);
             s2.setNo(123);
             System.out.print(studentmaker.equals(s1, s2));
	}

}

　　

4，绑定

向上转型与向下转型
向上转型：从子类型向父类型转换，自动的
向下转型：从父类型向子类型转换，使用强制转换的语法 ()

 

静态(前期)：在编译时能决定访问到谁的属性或方法 static，final修饰的成员或方法

动态(后期)：在运行时才能决定访问到谁的属性或方法，非static

 

instanceof关键字

instanceof是Java中的二元运算符，左边是对象，右边是类；当对象是右边类或子类所创建对象时，返回true；否则，返回false。
类的实例包含本身的实例，以及所有直接或间接子类的实例

instanceof左边显式声明的类型与右边操作元必须是同种类或存在继承关系，也就是说需要位于同一个继承树，否则会编译错误
使用该运算符的场景大部分情况是为了后续的向下转型，或称为保证类型安全

 

 

使用建议：
1，声明方法的时候，参数尽可能使用父类型
2，方法的返回值类型上，尽可能使用父类型

 

5，super
第一种用法：在普通方法（static方法除外）中调用父类中的属性或方法 super.
第二种用法：在子类的构造方法中，显式调用父类的构造方法 super()

 

 

6，类的初始化顺序

 

在子类构造方法调用时会首先调用父类的构造方法
执行的顺序：
父类静态代码块
子类静态代码块
父类代码块
父类的构造方法
子类的代码块
子类的构造方法
目的：了解初始化的顺序

 

 

7，final

 

使用场景及意义：
7.1 修饰变量，表示一个常量，一旦初始化就不可修改
方法中的局部变量：可以声明时赋初始值，可以在使用前赋值
类成员中的属性，可以声明时赋初始值，也可以在代码块或构造方法中赋值

如果是final修饰的引用类型变量，是不能重新赋值，但是其中的非final成员可以修改

final变量的命名一般是所有字母都大写，且使用下划线分隔
7.2 修饰方法，表示方法不能被子类重写
7.3 修饰类，表示该类不可被继承

 

 

定义一个汽车类Vehicle，要求如下：
（a）属性包括：汽车品牌brand（String类型）、颜色color（String类型）和速度speed（double类型）。
（b）至少提供一个有参的构造方法（要求品牌和颜色可以初始化为任意值，但速度的初始值必须为0）。
（c）为属性提供getter/setter方法。注意：汽车品牌一旦初始化之后不能修改。
（d）定义一个方法run()，用打印语句描述汽车奔跑的功能。
定义测试类VehicleTest，在其main方法中创建一个品牌为“benz”、颜色为“black”的汽车。

public class Car {
        
	private final  String brand;  
	private  String color;  
	private  double speed;  
	
	 public Car(String a,String b){
		 this.brand=a;
		 this.color=b;
		 this.speed=0;
	 }
	public String getBrand() {
		return brand;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public double getSpeed() {
		return speed;
	}
	public void setSpeed(double speed) {
		this.speed = speed;
	}
}

　　

public class Cartest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
           Car car=new Car("benz", "黑色");
           Run run=new Run();
           run.run(car);
	}
}

　　

public class Run {
       
	 public void run(Car c){
		 System.out.println(c.getColor()+"的"+c.getBrand()+"以"+c.getSpeed()+"速度奔跑");
	 }
}

　　

(2)定义一个Vehicle类的子类轿车类Car，要求如下：
（a）轿车有自己的属性载人数loader（int 类型）。
（b）提供该类初始化属性的构造方法。
（c）重新定义run()，用打印语句描述轿车奔跑的功能。
（d）定义测试类Test，在其main方法中创建一个品牌为“Honda”、颜色为“red”，载人数为2人的轿车

 

 

                             为了和这样的小姐姐共事，我一定会加油写代码的。