多态：
/*
多态(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 是子父类
}
}