多态：
/* 多态(polymorphic)概述 * 事物存在的多种形态 多态前提 * a:要有继承关系。 * b:要有方法重写。 * c:要有父类引用指向子类对象。 * 成员变量 * 编译看左边(父类)，运行看左边(父类)。 * 成员方法 * 编译看左边(父类)，运行看右边(子类)。动态绑定 * 静态方法 * 编译看左边(父类)，运行看左边(父类)。 * (静态和类相关，算不上重写，所以，访问还是左边的) * 只有非静态的成员方法,编译看左边,运行看右边 */ class Demo_Polymorphic { public static void main(String[] args) { Animal a = new Cat(); // 父类引用指向子类对象 a.eat(); // 猫吃鱼 // 如果父类没有eat方法就会报错，编译看左边(父类) System.out.println(a.num); // 10 成员变量，运行看父类 a.method(); // Animal static method ,相当于Animal.method() } } class Animal { int num = 10; public void eat(){ System.out.println("动物吃饭"); } public static void method(){ System.out.println("Animal static method"); } } class Cat extends Animal { int num = 20; public void eat(){ System.out.println("猫吃鱼"); } public static void method(){ System.out.println("Cat static method"); } }
/* * A:多态的好处 * a:提高了代码的维护性(继承保证) * b:提高了代码的扩展性(由多态保证) * B:可以当作形式参数,可以接收任意子类对象 * C:多态的弊端 * 不能使用子类的特有属性和行为。 */ class Demo_Polymorphic1 { public static void main(String[] args) { Animal a = new Cat();// 向上转型 a.eat(); Cat c = (Cat)a; //向下转型 c.method(); // Animal a2 = new Dog(); methods(new Dog()); } public static void methods(Animal a){ // 作形式参数 if (a instanceof Cat) { Cat c = (Cat)a; c.method(); } else if (a instanceof Dog) { Dog d = (Dog)a; d.method(); }else{ a.eat(); } } } class Animal { public void eat(){ System.out.println("动物吃饭"); } } class Cat extends Animal { public void eat(){ System.out.println("猫吃鱼"); } public void method(){ System.out.println("猫捉老鼠"); } } class Dog extends Animal { public void eat(){ System.out.println("狗吃肉"); } public void method(){ System.out.println("狗看门"); } }
抽象的特点：
/* 抽象类特点 * a:抽象类和抽象方法必须用abstract关键字修饰 * abstract class 类名 {} * public abstract void eat(); * b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口 * c:抽象类不能实例化那么，抽象类如何实例化呢? * 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。 * d:抽象类的子类 * 要么是抽象类 * 要么重写抽象类中的所有抽象方法 * * 抽象类特点B:抽象类特点 * a:抽象类和抽象方法必须用abstract关键字修饰 * abstract class 类名 {} * public abstract void eat(); * b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口 * c:抽象类不能实例化那么，抽象类如何实例化呢? * 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。 * d:抽象类的子类 * 要么是抽象类 * 要么重写抽象类中的所有抽象方法 */ class Demo_Abstract { public static void main(String[] args) { // Animal a = new Animal();//错误: Animal是抽象的; 无法实例化 new Cat().method(); } } abstract class Animal { public abstract void method(); public void eat(){ System.out.println("eat"); } } class Cat extends Animal { public void method(){ System.out.println("捉老鼠"); } }
抽象类的成员特点：
* 抽象类的成员特点
* a:成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量?不能修饰成员
变量
* b:构造方法：有。
* 用于子类访问父类数据的初始化。
* c:成员方法：既可以是抽象的，也可以是非抽象的。
* 抽象类的成员方法特性：
* a:抽象方法 强制要求子类做的事情。
* b:非抽象方法 子类继承的事情，提高代码复用性。
一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
* 可以
* 这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成
abstract不能和哪些关键字共存
abstract和static
被abstract修饰的方法没有方法体
被static修饰的可以用类名.调用,但是类名.调用抽象方法是没有意义的
abstract和final
被abstract修饰的方法强制子类重写
被final修饰的不让子类重写,所以他俩是矛盾
abstract和private
被abstract修饰的是为了让子类看到并强制重写
被private修饰不让子类访问,所以他俩是矛盾的
abstract class Demo { //public static abstract void print(); //错误: 非法的修饰符组合: abstract 和static //public final abstract void print(); //错误: 非法的修饰符组合: abstract 和final private abstract void print(); //错误: 非法的修饰符组合: abstract和private }
接口：
/* * A:接口概述 * 从狭义的角度讲就是指java中的interface * 从广义的角度讲对外提供规则的都是接口 * B:接口特点 * a:接口用关键字interface表示 * interface 接口名 {} * b:类实现接口用implements表示 * class 类名 implements 接口名 {} * c:接口不能实例化 * 按照多态的方式来实例化。 * d:接口的子类 * a:可以是抽象类。但是意义不大。 * b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案) */ class Demo_Interface { public static void main(String[] args) { // Inter i = new Inter();//错误: Inter是抽象的; 无法实例化 Inter i = new A(); // 按照多态的方式实例化 i.print(); new Y().print(); } } interface Inter { public abstract void print(); // 接口中的方法都是抽象的 } class A implements Inter { public void print(){ System.out.println("a"); } } /* 接口成员特点 * 成员变量；只能是常量，并且是静态的并公共的。 * 默认修饰符：public static final * 建议：自己手动给出。 * 构造方法：接口没有构造方法。 * 成员方法：只能是抽象方法。 * 默认修饰符：public abstract * 建议：自己手动给出。 */ interface X { public static final int num = 10; public abstract void print(); // public X(){}//接口没有构造方法 // public void print(){} // 只能是抽象方法 } class Y implements X { public Y(){ super(); // 父类object } public void print(){ System.out.println(num); } } class Demo3_Interface { public static void main(String[] args) { System.out.println("Hello World!"); } } /* * 类与类,类与接口,接口与接口的关系 * a:类与类： * 继承关系,只能单继承,可以多层继承。 * b:类与接口： * 实现关系,可以单实现,也可以多实现。 * 并且还可以在继承一个类的同时实现多个接口。 * c:接口与接口： * 继承关系,可以单继承,也可以多继承。 */ interface InterA { public abstract void printA(); } interface InterB { public abstract void printB(); } interface InterC extends InterB,InterA { } //class Demo implements InterA,implements InterB { //这么做不允许是非法的 class Demo extends Object implements InterA,InterB { public void printA() { System.out.println("printA"); } public void printB() { System.out.println("printB"); } }
class Demo3_Interface { public static void main(String[] args) { System.out.println("Hello World!"); } } /* * A:类与类,类与接口,接口与接口的关系 * a:类与类： * 继承关系,只能单继承,可以多层继承。 * b:类与接口： * 实现关系,可以单实现,也可以多实现。 * 并且还可以在继承一个类的同时实现多个接口。 * c:接口与接口： * 继承关系,可以单继承,也可以多继承。 */ interface InterA { public abstract void printA(); } interface InterB { public abstract void printB(); } interface InterC extends InterB,InterA { } //class Demo implements InterA,implements InterB { //这么做不允许是非法的 class Demo extends Object implements InterA,InterB { public void printA() { System.out.println("printA"); } public void printB() { System.out.println("printB"); } } class Demo3_Interface { public static void main(String[] args) { System.out.println("Hello World!"); } } /* * A:类与类,类与接口,接口与接口的关系 * a:类与类： * 继承关系,只能单继承,可以多层继承。 * b:类与接口： * 实现关系,可以单实现,也可以多实现。 * 并且还可以在继承一个类的同时实现多个接口。 * c:接口与接口： * 继承关系,可以单继承,也可以多继承。 */ interface InterA { public abstract void printA(); } interface InterB { public abstract void printB(); } interface InterC extends InterB,InterA { } //class Demo implements InterA,implements InterB { //这么做不允许是非法的 class Demo extends Object implements InterA,InterB { public void printA() { System.out.println("printA"); } public void printB() { System.out.println("printB"); } } class Demo3_Interface { public static void main(String[] args) { System.out.println("Hello World!"); } } /* * A:类与类,类与接口,接口与接口的关系 * a:类与类： * 继承关系,只能单继承,可以多层继承。 * b:类与接口： * 实现关系,可以单实现,也可以多实现。 * 并且还可以在继承一个类的同时实现多个接口。 * c:接口与接口： * 继承关系,可以单继承,也可以多继承。 */ interface InterA { public abstract void printA(); } interface InterB { public abstract void printB(); } interface InterC extends InterB,InterA { } //class Demo implements InterA,implements InterB { //这么做不允许是非法的 class Demo extends Object implements InterA,InterB { public void printA() { System.out.println("printA"); } public void printB() { System.out.println("printB"); } }
抽象类和接口的区别
* 成员区别 * 抽象类： * 成员变量：可以变量，也可以常量 * 构造方法：有 * 成员方法：可以抽象，也可以非抽象 * 接口： * 成员变量：只可以常量 * 成员方法：只可以抽象 * 关系区别 * 类与类 * 继承，单继承 * 类与接口 * 实现，单实现，多实现 * 接口与接口 * 继承，单继承，多继承 * 设计理念区别 * 抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。 * 接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。
为什么要有包：
* 将字节码(.class)进行分类存放
* 包其实就是文件夹
包的定义及注意事项
* A:定义包的格式
* package 包名;
* 多级包用.分开即可
* B:定义包的注意事项
* A:package语句必须是程序的第一条可执行的代码
* B:package语句在一个java文件中只能有一个
* C:如果没有package，默认表示无包名
如何编译运行带包的类：
* a:javac编译的时候带上-d即可
* javac -d . HelloWorld.java
* b:通过java命令执行。
* java 包名.HellWord
import关键字的概述和使用：
* 为什么要有import
* 其实就是让有包的类对调用者可见,不用写全类名了
* 导包格式
* import 包名;
* 注意：
这种方式导入是到类的名称。
虽然可以最后写*，但是不建议。
四种权限修饰符：
| 本类 | 同一个包下(子类和无关类) | 不同包下(子类) | 不同包下(无关类) | |
| private | Y | |||
| 默认 | Y | Y | ||
| protected | Y | Y | Y | |
| public | Y | Y | Y | Y |
类及其组成所使用的常见修饰符：
* A:修饰符： * 权限修饰符：private，默认的，protected，public * 状态修饰符：static，final * 抽象修饰符：abstract * B:类： * 权限修饰符：默认修饰符，public * 状态修饰符：final * 抽象修饰符：abstract * 用的最多的就是：public * C:成员变量： * 权限修饰符：private，默认的，protected，public * 状态修饰符：static，final * 用的最多的就是：private * D:构造方法： * 权限修饰符：private，默认的，protected，public * 用的最多的就是：public * E:成员方法： * 权限修饰符：private，默认的，protected，public * 状态修饰符：static，final * 抽象修饰符：abstract * 用的最多的就是：public * F:除此以外的组合规则： * 成员变量：public static final 接口 * 成员方法： * public static * public abstract * public final
内部类访问特点 * a:内部类可以直接访问外部类的成员，包括私有。 * b:外部类要访问内部类的成员，必须创建对象。 * 外部类名.内部类名 对象名 = 外部类对象.内部类对象; class Demo_Inner { public static void main(String[] args) { Outer.Inner oi = new Outer().new Inner(); oi.method(); // 访问内部类的私有使用 Outer2 o = new Outer2(); o.print(); // 访问静态成员内部类 Outer3.Inner o3 = new Outer3.Inner(); o3.method(); Outer4.Inner.method(); } } class Outer { private int num = 10; class Inner { public void method(){ System.out.println(num); } } } // 内部类的私有使用 class Outer2 { private int num = 10; private class Inner { public void method(){ System.out.println(num); } } public void print(){ new Inner().method(); } } /* 静态成员内部类 * 成员内部类被静态修饰后的访问方式是: * 外部类名.内部类名 对象名 = 外部类名.内部类对象; */ class Outer3 { static class Inner { public void method(){ System.out.println("static"); } } } class Outer4 { static class Inner { public static void method(){ System.out.println("static"); } } }
使用已知的变量，在控制台输出30，20，10。
// 内部类之所以能获得外部类的成员，是因为他能获取到外部类的引用 外部类名.this class Outer { public int num = 10; class Inner { public int num = 20; public void show() { int num = 30; System.out.println(num); System.out.println(this.num); System.out.println(Outer.this.num); } } } class InnerClassTest { public static void main(String[] args) { Outer.Inner oi = new Outer().new Inner(); oi.show(); } } class Demo_InnerClass { public static void main(String[] args) { Outer o = new Outer(); o.method(); } } // 局部内部类 class Outer { public void method(){ final int num = 10; // 局部内部类访问局部变量必须用final修饰 class Inner { public void print(){ System.out.println(num); } } new Inner().print(); } /* public void Test(){ new Inner().print();// 错误，局部内部类，只能在其所在的方法中访问 } */ } /* * 局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么? 因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周 期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部 变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可 以继续使用 但是jdk1.8,如果在书写代码时候,没有手动添加,系统底层也会默给你final */
匿名内部类：
/* * A:匿名内部类 * 就是内部类的简化写法。 * B:前提：存在一个类或者接口 * 这里的类可以是具体类也可以是抽象类。 * C:格式： new 类名或者接口名(){ 重写方法; } * D:本质是什么呢? * 是一个继承了该类或者实现了该接口的子类匿名对象。 */ class Demo_InnerClass2 { public static void main(String[] args) { new Outer().method(); } } interface Inner { public abstract void print(); } class Outer { public void method(){ new Inner(){ public void print(){ System.out.println("Hello World!"); } }.print(); } } // 匿名内部类重写多个方法调用 // 建议匿名类只针对重写一个方法时候使用 interface Inner2 { public abstract void print1(); public abstract void print2(); } class Outer2 { public void method(){ Inner2 i = new Inner2(){ // 父类引用指向子类对象 public void print1(){ System.out.println("print1"); } public void print2(){ System.out.println("print1"); } /* public void print3(){ System.out.println("print3"); } */ }; i.print1(); i.print2(); // i.print3(); // 匿名内部类是不能向下转型的，因为没有自类类名 } }
class Test_NoNameInnerClass { public static void main(String[] args) { Outer.method().show(); // 相当于 Inter i = Outer.method(); i.show(); } } interface Inter { void show(); } class Outer { public static Inter method(){ return new Inter(){ public void show(){ System.out.println("Hello World!"); } }; } } /* Hello World! */
重写补充：返回值类型是子父类
/* 重写:子父类出现了一模一样的方法 (注意:返回值类型可以是子父类） */ class Demo_FaSonClass { public static void main(String[] args) { } } class Person { public void print(){ System.out.println("Hello World!"); } } class Person2 extends Person { public void print(){ System.out.println("Hello World!2"); } } class Father { public Person method(){ return new Person(); //Person与Person2 是子父类 } } class Son extends Father { public Person2 method(){ return new Person2(); //Person与Person2 是子父类 } }