20190801——抽象方法，数据类型深度学习

一、tips
1、类和类：单继承（是不是关系）
接口和类：多实现（是否拥有关系）
接口和接口：多继承

二、知识点

9.抽象类
定义:使用abstract修饰的类就是抽象类
使用abstract修饰的方法就是抽象方法,抽象方法没有方法体.
一般把父类定义为抽象类
public abstract class Bi {
//抽象方法
public abstract void xiezi();
}

9.1.抽象类和抽象方法之间的关系
抽象类中可以没有抽象方法
如果存在抽象方法，则这个类必须是一个抽象类

9.2.抽象类的一些特点
抽象类是可以没有抽象方法的。
抽象类不能实例化(创建对象)
构造函数不能是抽象方法
抽象方法不能是私有的
当子类继承一个抽象类的时候，必须要重写抽象类中所有的抽象方法，除非子类也是一个抽象类
9.3.
10.接口
10.1.接口的关键字是interface
Public interface 接口名称{
}
10.2.接口是一种特殊的抽象类，要求接口中的所有方法都是抽象的
不能有方法体。接口中的抽象方法可以不加abstract关键字修饰默认就是抽象的
接口方法的访问修饰符，默认就是public,如果写只能是public

如果接口中的方法是静态的，则需要为该方法提供方法的实现
如果接口中的方法是默认的，则需要为该方法提供方法的实现
接口中不能有构造函数
接口不能实例化
public interface MyInterface {
//接口中定义的方法默认就是抽象的没有方法体,且访问修饰符只有public 一种
public void test_method();
void test_mehtod2();
//错误，接口中不能有构造函数
//public MyInterface(){ }

public static void test_static_method(){
	System.out.println("这是接口中的一个静态方法");
}
public static void test_static_method2(){
	System.out.println("这是接口中的一个静态方法2");	
} 
public default void test_default_mehtod1(){
	System.out.println("这是接口中默认的方法");
}

}

10.3.接口中的属性
接口中的属性必须是常量 必须赋值
接口中的属性访问修饰符只有(public 和 默认) 默认的也是public
默认常量的命名规范的所有字母都大写

//若果在普通类中定义定义常量需要使用public static final三个修饰符修饰，三个修饰符顺序可以调换
Public static final String NAME=”BEIJING”;
Static public final String NAME =”BEIJIN”;
public interface Inter {
// 接口中的属性
public String NAME=“三生三世”;
String SEX =“女”;
public static final String ADDRESS=“BEIJIMNG”;
static public final String BIRTHDAY=“1987-11-11”;
//protected String address=“北京”;//错误
//定义的所有方法都是抽象的
public void say();
public void eat();
void drink(); //默认的也是public
//接口中的静态方法
static void sing(){
System.out.println(“ssssssssssssss”);
}
// private void test();//错误
// protected void abc();//错误
}

10.4.接口中的继承
10.4.1.接口继承接口是多继承关系
public interface Inter12 extends Inter1,Inter2{
}

10.4.2.类继承接口:一个类实现了多个接口
一个类可以实现多个接口，需要这个类重写接口中的所有抽象方法，如果多个父接口中存在同名方法，只需要重写其中的一个就可以。
抽象类可以实现多个接口
public class MyClass implements MyInterface,MyInterface2 {
//接口一中存在 test_mehto(),test_mehto2(),mehtod2() 三个抽象方法
//接口二中存在method2()一个抽象方法，
//则类中就可以重写三个即可
@Override
public void test_method() {
}
@Override
public void test_mehtod2() {
}
@Override
public void method2() {
}
}

10.4.3.类继承类 : 类和类之间是单继承，一个类的直接父类只能有一个
类和类之间是单继承( extend一类只能继承一个父类)
类和接口之间是多实现(implements一个类可以实现多个接口)
接口和接口之间是多继承(exetend一个接口可以继承多个接口)

类和类之间的继承称之为 is-a 的关系 （是不是的关系）
Student 和 person student 是不是 person 如果是 就是继承
类和接口之间的实现关系称之为 hs-a的关系(是否拥有的关系)
FlyInter(飞的接口) 和 鸟， 飞机 (飞机拥有飞的行为，鸟 拥有飞的行为)
接口只是行为的规范

10.5.接口继承以后的向上转型(也是可以实现多态的)
飞行的功能鸟可以有，飞机也可以有，如果想要看飞行的表演，我们就需要定义一个父接口，只要拥有接口的功能都可以进行飞行表演
//飞行接口的信息
public interface FlyInterface {
//可以飞的方法
void fly();
}
//小鸟实现类信息
public class Bird implements FlyInterface {
private String name;
public Bird(String name){
this.name = name;
}
@Override
public void fly() {
System.out.println(“天上的”+name+“在飞翔”);
}
public void zuochongzi(){
System.out.println(“捉虫子”);
}
}
//飞机实现类的信息你
public class Plane implements FlyInterface {
private String name;
public Plane(String name){
this.name = name;
}
@Override
public void fly() {
// TODO Auto-generated method stub
System.out.println(“驾驶员开着”+name+",在天上打仗");
}
public void tubaiyan(){
System.out.println(“吐白烟”);
}
}
//使用类的信息
public class BiaoYan {
public void kanbiaoyan(FlyInterface fly){
fly.fly();
}
}
//测试类的信息
public class Test {

public static void main(String[] args) {
	BiaoYan by = new BiaoYan(); 
	Bird bird=new Bird("鸽子");
	Plane plane = new Plane("J20"); 
	//多态
	by.kanbiaoyan(bird);
	by.kanbiaoyan(plane); 
	//测试向上转型 以后只能调用接口中定义的方法
	FlyInterface fly = bird;
	
	fly = plane;
} 

}

10.6.接口和抽象类实现多态的案例

11.Final 的讲解
final最终的 ，它可以修饰变量，方法和类
Final 在修饰的时候位置可以和访问修饰符互换
Final public int num = 20;
Public final int num =20;

11.1.使用final修饰变量
当一个变量被final修饰后，这个变量就称为常量
常量的特点：在声明的时候必须赋初始值,不可以先声明后赋值
Final int num = 22; 正确 final int num; num = 22;错误
常量一旦定义完毕，程序在整个执行过程中不能被重新赋值

如果final 修饰的是基本数据类型( final int num = 30;)该变量的值不能修改
如果fianl修饰的是引用数据类型(fint Student stu = new Student()? 则stu保存的对象不能变化，但对象的属性是可以修改的。
public class StaticTest {
//基本数据类型的常量
public final static int num = 20;
//引用数据类型的常量
public final static Student STU = new Student(“赵丽丽”,“女”) ;

public void testNum(){
	//常量的值不能修改
	 //num= num+20; 
	//不能为stu这个常量重新赋一个对象
	//STU = new Student();
	//但可以stu对象中的某个属性的值修改
	STU.setName("王晓军军");
	STU.setSex("男");
	
}

一般常量在定义的时候需要所有的字母大写
一般在一个程序中常量是统一定义在工具类中的

11.2.使用final修饰的方法
Final 修饰的方法称为最终方法，该方法只能继承，不能重写；可以重载

11.3.使用final修饰的类
Public final class
Final 修饰的类称为最终类，不能被继承
String ,Double,Integer,Float,Byte 这些包装类，都是final修饰的类，都不能被继承

12.Static 关键字
Static称作静态内容，可以直接修饰：变量，代码块，方法 ，修饰类的时候只能是内部类

代码块:
有一对{}组成 ,分为实例代码块{}和静态代码块 static{}
实例代码块，随着创建对象的个数进行初始化的，创建几个对象执行几次示例代码库的功能,一般用于设定初始化信息,一般使用的还是比较少的。
静态代码块：整个执行过程只执行一次，一般用于读取外部资源文件。在第一次使用该类的时候执行（Teacher t; 这个不叫第一使用 。 Teacher.test() 或 Teacher a = new Teacher() ）
静态代码块的优先级高于实例代码块;
静态成员(代码块，变量，方法) 的优先级高于实例成员（代码块，变量，方法）

12.1.Static 修饰属性
当使用static修饰属性的时候，我们称之为静态属性，也称为类属性类变量
实例变量：只能由对象调用,每一个对象都有一个实例变量的副本，不能有类调用
(stu.name = ‘张三’ stu2.name = “李四”)
静态变量：属于类的，整个类共享一个值，所有的对象页共享同一个静态变量的值.而实例变量属于对象每个对象都有一个值
一般情况，静态变量需要通过类名直接调用 Student.address =”河北张家口”;
对象调用也可以，但会报警告

静态的内容的优先级高于实例内容
Static 不能修饰局部变量

12.2.Static 修饰方法
Static 修饰的方法是静态方法
静态方法中只能调用静态成员(静态属性和静态方法)
实例方法中可以调用所有的成员(静态的和非静态的都可以)
在静态方法中不能出现this,super关键字
原因：this作为当前对象在类名调用静态方法的时候还不存在当前对象

注意:静态方法也是可以被继承的。如果子类也出现了同名的静态方法这时候子类的方法覆盖了继承的父类方法
在向上转型后父类引用调用的静态方法必须是父类中定义的方法而非子类中定义的方法 Person p = new Teacher() p.say()(如果say是一个静态方法，则调用的是父类中定义的。)
静态方法不能有多态。
父类中存在say()方法
public class Person {
public static void say(){
System.out.println(“父类这是一个静态的方法”);
}
public void eat(){
System.out.println(“这是父类吃饭的方法”);
}
}

子类中也出现了say()方法(子类的say()方法覆盖了父类的say()方法)
public class Teacher extends Person {
private String name;
public static void say(){
System.out.println(“这是子类的静态”);
}
public void eat(){
System.out.println(“这是子类吃饭的方法”);
}
在向上转型以后父类引用只能调用父类的静态方法
public static void main(String[] args) {
Person p = new Teacher();
p.say(); //父类的方法
p.eat(); //子类重写后的
Teacher t = new Teacher();
t.say(); //子类的方法
t.eat();
}

类的组成：代码块,属性,方法
代码块,属性,方法 有分为:静态的和实例的
类的组成：(静态代码块，实例代码块,静态属性，实例属性,静态方法，实例方法，构造方法不能是静态的)

所有的静态内容都属于类，只有类名能调用,
静态内容的优先级高于实例内容
实例内容属于对象，对象可以调用实例内容也可以调用静态内容
13.
14.Object
在JAVA中所有的类都是Object的直接子类或间接子类
一切皆为对象: Object
所有类的对象都可以声明成Object引用
Object obj = new Student();Object obj = new Person();

14.1.equals方法的作用
== 和 equals的区别
在 Object类中equals() 默认的实现 this == obj
== 用于判断对象在内存中的位置(如下图)

但是在String类，包装类中，equals方法已经被重写了，改变了原有的实现方式。变成了比较内容了

 Student stu1 = new Student(“zhaolili”);

Student stu2 = new Student(“zhaolili”)
Stu1 ==stu2 的效果和 stu1.equals(stu2)的效果是一致的

如果自定义的类想要把equals方法实现为比较内容需要重写
public class Computer {
private String name;
private String address;
@Override
public boolean equals(Object obj) {
if(this == obj)
return true;
if(obj instanceof Computer){
Computer c = (Computer)obj; //向下转型
//有可能报控制正异常
if(c.name.equals(this.name) && c.address.equals(this.address))
return true;
return false;
}
return false;
}}

14.2. getClass方法的作用
可以获取当前对象所在类的所有信息, 一般在框架的反射部分会使用的
Computer computer1 = null;
computer1 =new Computer(“联想”);
System.out.println( computer1.getClass());

class com.xja.demo.Computer
获取当前对象的类型

14.3. hashCode方法的作用
Java中的hashCode方法就是根据一定的规则将与对象相关的信息（比如对象的存储地址，对象的字段等）映射成一个数值，这个数值称作为散列值。
哈希码本身来说就是一种为了提高查找效率的一种算法，例如：HashSet、HashMa以及HashTable

同一个对象的hashcode一定相同，不同的对象可能会生成相同的hashcode值。
不能根据hashcode值判断对象是否相等，但可以两个对象不等，如果两个对象的hashcode值不等，则必定是两个不同的对象。

14.4. toString() 返回当前对象的字符串形式
类型@hashCode
当输出单个对象的时候默认要调用toString()方法
Computer computer2 = null;
computer2 =new Computer(“联想”);
computer2.setAddress(“河北张家口”);
System.out.println(“默认调用的是:”+computer2);
System.out.println(“默认调用的是 :”+computer2.toString());

可以通过重写 toString方法，实现对象属性的打印
@Override
public String toString() {
return “Computer [name=” + name + “, address=” + address + “]”;
}

	Computer computer2 = null;
	computer2 =new Computer("联想");
	computer2.setAddress("河北张家口");
	System.out.println("默认调用的是:"+computer2);
	System.out.println("默认调用的是 :"+computer2.toString()); 

默认调用的是toString :Computer [name=联想, address=河北张家口]
默认调用的是 :Computer [name=联想, address=河北张家口]

14.5.Wait() 线程等待
14.6.notify() 唤醒指定的线程对象
14.7.finalize() 回收对象的方法
当一个对象不再被任何引用指向的时候，这个对象就是一个垃圾对象，该对象所占的空间就会被收回
Computer computer1 = null;
//创建了第一个对象
computer1 =new Computer(“联想”);
Computer computer2 = null;
//创建了第二个对象
computer2 =new Computer(“华为”);
//把第二个引用的值赋予第一个引用
computer1 = computer2;
//这时候连个引用都指向了第二个对象，第一个对象就是没有被引用的对象就会被收回

14.8.包装类8个基本数据类型对应的类
在java中一切皆为对象, (8个基本数据类型就不是对象)

14.9.包装类和字符串之间的相互转换
//把字符串装换成包装类 “abc”
String numstr=“123”;
Integer numObj = new Integer(numstr);
Integer numObj2 = Integer.getInteger(numstr);
Integer numObj3 = Integer.valueOf(numstr);
//把包装类转换成字符串
String numstr2 = numObj.toString();

14.10.基本数据类型和字符串之间的相互转换
//把基本数据类型转换成字符串
int num = 123;
String numstr3 = num+"";
String numstr4 = String.valueOf(num);
//把字符串转换成基本数据类型
int num2 = Integer.parseInt(numstr3);

14.11.基本数据类型和包装类之间的转换
装箱: 把基本数据类型的值直接赋予包装类的对象
Int num = 22;
Integer numobj = num; //装箱
拆箱：把包装类的对象直接赋值给基本数据类型的变量
Integer numobj = new Integer(45);
Int num = numobj; //拆箱
//基本数据类型和包装类之间的互相转换(装箱和拆箱)
int num3 = 20;
Integer numobj = num3; //装箱
int num4 = numobj; //拆箱

14.12.Object和 数据类型直接的转换
int num5 = 20;
Object a = num5; //装箱和向上转型两件事(Integer num = num5; Object a = num;)
int nums = (int)a;