/**
面向过程：1.打开冰箱 2.存储大象 3.关上冰箱。强调的过程（动作、功能、函数）。
面向对象：强调的是对象（实体）。冰箱【1.打开 2.存储 3.关闭】 调用
特点：1.面向对象就是一种常见的思想，符合人们的思考习惯。
2.面向对象的出现，将复杂的问题简单化。
3.让曾经在过程中的执行者，变成了对象中的指挥者(调用者)。
*/一、面向对象：类和对象。
1.类是抽象的，概念的，代表一类事物。
2.对象是具体的，实际的，代表具体的事物。
3.类是对象的模板，对象是类的一个个体，实例。
成员变量是类的一个组成部分，一般是基本数据类型，也可以是引用类型（地址值）。
声明再创建：类名 对象名 ＝ new 类名（）；
对象－如何访问（使用）对象的成员变量：对象名.成员变量。
二、抽象类：
抽象：笼统，模糊，看不懂，不具体
特点：1.方法只有声明没有实现时，该方法就是抽象方法，需要被abstrace修饰。抽象方法必须定义在抽象类中，该类也必须被abstract修饰。
2.抽象类不可以被实例化。因为调用抽象方法没意义（没方法体）。
3.抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化，否则，这个子类还是抽象类。
1.抽象类中有构造函数吗？
有，用于给子类对象进行初始化。
2.抽象类可以不定义抽象方法吗？
可以的。但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。
通常这个类的方法有方法体，单是却没有内容。
3.抽象关键字不可以和哪些关键字共存？
private 不行
static 不行 类方法，只能类调用
final 不行
4.抽象类和一般类的异同点？
相同：抽象类和一般类都是用来描述事物的，都在内部定了成员。
不同：1.一般类有足够的信息描述事物，抽象类描述事物的信息有可能不足。
2.一般类不能定义抽象方法，只能定义非抽象方法。 抽象类可以定义抽象方法，同时也可以定义非抽象方法。
3.一般类可以被实例化，抽象不可以被实例化。
5.抽象类一定是父类吗？
是的，需要子类覆盖其方法后才可以对子类实例化。
abstract class Demo
{
abstract void show();
//{
//System.out.println("demo show");
//}
}
//DemoA和DemoB有共性，进行抽象成一个类。
class DemoA extends Demo
{
void show()
{
System.out.println("demoA show");
}
/*
void show()
{
System.out.println("demo show");
}
*/
}
class DemoB extends Demo
{
void show()
{
System.out.println("demoB show");
}
/*
void show()
{
System.out.println("demo show");
}
*/
}
class AbstractTest
{
public static void main(String[] args)
{
Demo a = new Demo();
}
}
三、接口
1、接口：初期理解，可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的方式来表示。
class：用于定义类
interface：用于定义接口
2、接口定义时，格式特点：
定义接口使用的关键字不是class，而是interface 。
对于接口当中常见的成员：而且这些成员都有固定的修饰符。
1.全局常量：public static final 默认存在修饰符（不管修饰不修饰）。
2.抽象方法：public abstract
由此得出结论，接口中的成员都是公共的权限。
/接口不再用继承，而是用实现（全都重写）
//类与接口的实现关系。类与类之间是继承关系。
接口不可以实例化。只能由实现了接口的子类并覆盖了接口中所有的抽象类的方法后，该子类才可以实例化。否则，这个子类就是一个抽象类。
接口是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。
接口可以被类多实现，一个类可以同时实现多个类。一个类在继承另一个类的同时，还可以实现多个接口。
接口与接口之间是继承关系，而且接口可以实现多继承关系。
接口的出现避免了单继承的局限性。
在java 中不直接支持多继承，因为会出现调用的不确定性，所以在java将多继承机制进行改良，在java中变成了多实现。一个类可以实现多个接口。
类与类之间是继承关系
类与接口之间是实现关系
接口与接口之间是继承关系。
3、接口的特点：1.接口是对外暴露的规则。2.是程序的功能扩展。3.接口可以用来多实现
4.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
5.接口与接口之间可以有继承关系。
相同点：都是不断向上抽取而来的。
不同点：1.抽象类需要被继承，而且只能单继承 接口需要被实现，而且可以多实现
2.抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用费抽象方法。接口只能定义抽象方法，必须由子类去实现。
3.抽象类的继承，是is a关系，在定义该体系的基本共性内容。 接口的实现是like a 关系，在定义体系外额外功能。
四、多态：本类事物即具备本类的形态，也具备了父类的形态
class Animal
{}
class Cal extends Animal
{}
class Dog extends Animal
{}
Cal c = new Cal();
Animal a = new Cal();这就是对象的多态性。
简单说：就是一个对象对应着不同类型。
猫 x = new 猫()
动物 x = new 猫()
1.多态的体现:
父类的引用指向了自己的子类对象
Animal a = new Cat();
父类的引用可以接收子类对象
2.多态的前提：必须是类与类之间的有关系，要么继承，要么实现。通常还有一个前提：存在覆盖
3.多态的好处：多态的出现大大扩大程序的扩展性。
4.多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类的成员。
多态的特点：
1、在多态中非静态成员函数的特点：（重写特性）
在编译时期，参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期，参阅对象所属类中是否有调用的方法。
简答总结就是：成员函数在多态调用时，编译看左边，运行时看右边。
2、在多态中成员变量的特点：
无论编译和运行，都参考左边（引用性变量所属的类）
3、在多态中，静态成员函数的特点：
无论编译和运行，都参考左边。
Animal a = new Cat();
//自动类型提升，猫对象提升为动物类型。访问出现局限性，但子类的特有功能无法访问
//作用：限制对特有功能的访问。
//专业讲：向上转型。
Cat c = (Cat)a;//向下转型，使得子类特有功能得到调用。 public static void method(Animal a)
{
if(a instanceof Cat)//instanceof：用于判断对象的具体类型，只能用于引用数据类型判断
{
//通常在向下转型前用于健壮性的判断
Cat c = (Cat)a;
c.eat();
c.catchMouse();
}
else if(a instanceof Dog)
{
Dog d = (Dog)a;
d.kanjia();
}
else
{
Pig p = (Pig)a;
p.gongdi();
}
}五、内部类：将一个类定义在另一个类里面，对里面那个类就称为内部类（内置类，嵌套类）。
访问规则：
1.内部类可以直接访问外部类中的成员，包括私有的。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用：外部类名.this
2.外部类要访问内部类，必须建立内部类对象。
访问格式：
1.当内部类定义外部类的成员位置上，而且非私有，可以在外部类其他类中。可以直接建立内部类对象。
格式：外部类名.内部类名 变量名=外部类对象.内部类对象。
Outer.Inner in = new Outer().new Inner();
2.当内部类在成员位置上，就可以被成员修饰符所修饰。
比如，private：将内部类在外部类中进行封装。
static:内部类就具备static的特性。
当内部类被static修饰后，只能访问外部类中static，出现局限性。
在外部其他类中，如何直接访问static内部类的非静态成员。
new Outer.Inner().function();
在外部其他类中，如何直接访问static内部类中的静态成员。
Outer.Inner.function();
注意：当内部类中的定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类也必须是static.
当描述事物时，事物的内部还有事物，该事物用内部类来描述。
*/
class Outer
{
int x = 3;
static class Inner //内部类 静态
{
//int x = 4;
void function()
{
System.out.println("inner:"+Outer.x);
//int x = 6;
/*
System.out.println("inner :"+x);
System.out.println("inner :"+this.x);
System.out.println("inner :"+Outer.this.x);
*/
}
}
class Inner2
{
void show()
{
System.out.println("inner show");
}
}
void method()
{
Inner in = new Inner();
in.function();
}
}
class InnerClassDemo
{
public static void main(String[] args)
{
//Outer out = new Outer();
//out.method();
//直接访问内部中的成员。
Outer.Inner in = new Outer().new Inner();
in.function();
}
}
/*
static是成员变量修饰符，不是局部变量修饰符。
内部类定义在局部时，
1.不可以被成员修饰符修饰
2.可以直接方位外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。
*/
class Outer
{
int x = 123;
//void method()
void method(final int a)
{
final int y = 4;
//int y = 4;
/*
内部类定义在局部时，不可以被成员修饰符修饰，可以直接访问外部类中的成员，
因为还持有外部类中的引用，但是不可以访问它所在的局部中的变量，只能访问
final修饰的局部变量
*/
class Inner
{
//static void function()会报错
void function()
{
System.out.println(y);
System.out.println(Outer.this.x);
System.out.println(a);
}
}
new Inner().function();
}
}
class InnerClassDemo3
{
public static void main(String[] args)
{
new Outer().method(777);
Outer out = new Outer();
//out.method(999);
//out.method(888);
}
}
/*
匿名内部类：
1.匿名内部类其实就是内部类的简写格式
2.定义匿名内部类的前提：内部类必须是继承一个类或者实现接口
3.匿名内部类的格式：new父类或者接口(){定义子类的内容}
4.其实匿名内部类就是一个匿名子类对象。
5.匿名内部类中定义方法最好不要超过三个。
*/
abstract class AbsDemo
{
abstract void show();
//abstract void show1();
//abstract void show2();
//abstract void show3();
}
class Outer
{
int x = 5;
/*
class Inner extends AbsDemo //内部类继承了一个外部其他类
{
//复写
void show()
{
System.out.println("show:"+x);
}
}
*/
public void function()
{
//Inner in = new Inner();
//in.show();
//in.abc();
//new Inner().show();
//new AbsDemo();闯将一个AbsDemo对象会出错，抽象类不可以创建一个对象。
//匿名内部类：方法只能被调用一次。
AbsDemo d = new AbsDemo()
//new AbsDemo()
{
void show()
{
System.out.println("x="+x);
}
void abc()
{
System.out.println("abc");
}
//}.show();//指的是调用其中的某个方法
};
d.show();
//d.abc();//编译失败;
/*
class Inner extends AbsDemo //内部类继承了一个外部其他类
{
//复写
void show()
{
System.out.println("show:"+x);
}
}
*/
}
}
class InnerClassDemo5
{
public static void main(String[] args)
{
new Outer().function();
}
}
扫一扫
874
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
