面向对象 复习（二）

代码块

      概述
  在Java中，使用{}括起来的代码被称为代码块。

     代码块分类
  根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。

     常见代码块的应用
   局部代码块 
  在方法中出现；限定变量生命周期，及早释放，提高内存利用率
   构造代码块 
  在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
   静态代码块 
  在类中方法外出现，加了static修饰
  在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，先于主方法，并且只执行一次。
  用于加载驱动

继承Extends

         继承的好处
 提高了代码的复用性
 提高了代码的维护性
 让类与类之间产生了关系，是多态的前提
               继承的弊端
 类的耦合性增强了
继承的特点
  支持单继承，支持多层继承。但不支持多继承
  如果想用这个体系的所有功能用最底层的类创建对象
  如果想看这个体系的共性功能,看最顶层的类 
继承的注意事项
  子类只能继承父类所有非私有的成员(成员方法和成员变量)
  子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
  不要为了部分功能而去继承
        什么时候使用继承
  继承其实体现的是一种关系："is a"。
  如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

this和super的区别

 调用成员变量
  this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
  super.成员变量 调用父类的成员变量
 调用构造方法
  this(...)
调用本类的构造方法
  super(...)调用父类的构造方法
 调用成员方法
  this.成员方法 调用本类的成员方法,也可以调用父类的方法
  super.成员方法 调用父类的成员方法
为什么子类中所有的构造方法默认都会访问父类中空参数的构造方法？

           因为子类会继承父类中的数据，可能还会使用父类的数据。
  所以，子类初始化之前，一定要先完成父类数据的初始化。

 其实：
  每一个构造方法的第一条语句默认都是：super()
  如果父类没有空参构造就在super()中加参数访问有参构造

注意：
super(…)或者this(….)必须出现在空参中的第一条语句上

 什么是方法重写
 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。
 方法重写注意事项
 父类中私有方法不能被重写
 因为父类私有方法子类根本就无法继承
 子类重写父类方法时，访问权限不能更低
 最好就一致
 父类静态方法，子类也必须通过静态方法进行重写
 其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解(静态只能覆盖静态)

 子类重写父类方法的时候，最好声明一模一样

 方法重写的面试题
 Override和Overload的区别?Overload能改变返回值类型吗?
 overload可以改变返回值类型,只看参数列表
 方法重写：子类中出现了和父类中方法声明一模一样的方法。

 方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值无关。

 子类对象调用方法的时候：
 先找子类本身，再找父类

public static void main(String[] args) {
Dog d1 = new Dog();
d1.setColor("黄");
d1.setLeg(4);

System.out.println(d1.getColor() + "," + d1.getLeg());

Dog d2 = new Dog("黑",2);
System.out.println(d2.getColor() + "," + d2.getLeg());
}
}

class Animal {
private String color;
private int leg;

public Animal(){}

public Animal(String color,int leg) {
this.color = color;
this.leg = leg;
}

public void setColor(String color) {
this.color = color;
}

public void setLeg(int leg) {
this.leg = leg;
}

public String getColor() {
return color;
}

public int getLeg() {
return leg;
}

public void eat() {
System.out.println("吃饭");
}
}

class Cat extends Animal2 {
public Cat(){}

public Cat(String color,int leg) {
super(color,leg);
}

public void catchMouse() {
System.out.println("抓老鼠");
}
}

class Dog extends Animal2 {
public Dog(){}

public Dog(String color,int leg) {
super(color,leg);
}

public void lookHome() {
System.out.println("看家");
}
}

final关键字

/*
final是最终的
final可以修饰类,方法和变量
final修饰的类,不可以被继承(丁克家庭)
final修饰的方法,不可以被重写
final修饰的变量,又称之为常量
*/

public static void main(String[] args) {
final int num = 10;				//final修饰基本数据类型变量不改变其值
System.out.println(num);

final Person2 p1 = new Person2("张三",23);//0x0011
//p1 = new Person("李四",24);//0x0022
p1.setName("李四");				//final修饰引用数据类型变量不改变其地址值
p1.setAge(24);					//但是可以改变对象的属性值

System.out.println(p1.getName() + "," + p1.getAge());
}
}

class Person2 {
private String name;
private int age;

public Person2(){}

public Person2(String name,int age) {
this.name = name;
this.age = age;
}

public void setName(String name) {
this.name = name;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
re
cdf6
turn name;
}

public int getAge() {
return age;
}
}

public static void main(String[] args) {
Demo d = new Demo();
//System.out.println(d.NUM);
d.show();
}
}
/*

final修饰变量的初始化时机在对象构造完毕前即可。因为创建对象先走构造
final修饰的变量
1,第一种赋值,定义时就直接赋值
2,第二种赋值,构造函数赋值
*/
class Demo {
final int NUM;

public Demo() {
NUM = 10;
}
public void show() {
//NUM = 10;
System.out.println(NUM);
}
}

多态

        多态是事物存在的多种形态

     多态的前提

     多态的三个前提
1,继承
2,要有重写
3,父类引用指向子类对象
      多态中的编译和运行
成员变量:编译看左边,运行看左边
成员方法:编译看左边,运行看右边(动态绑定)
静态的成员方法:编译看左边,运行看左边
静态的成员方法不存在覆盖的说法
只有非静态的成员方法,编译看左边(父类)运行看右边(子类)

/*多态的好处
* a:提高了代码的维护性(继承保证)
* b:提高了代码的扩展性(由多态保证)

多态的弊端
* 不能使用子类的特有功能。*/
public static void main(String[] args) {
Person p = new SuperMan();				//父类引用指向子类对象(自动类型提升,向上转型)
System.out.println(p.name);

p.谈生意();
//	p.fly();           父类不能调用子类特有功能但可以向下转型
SuperMan sm = (SuperMan)p;				//向下转型
sm.fly();
}
}
class Person {
String name = "约翰";
public void 谈生意() {
System.out.println("谈生意");
}
}

class SuperMan extends Person {
String name = "超人";

public void 谈生意() {
System.out.println("谈几个亿的大单子");
}

public void fly() {
System.out.println("飞出去救人");
}

抽象类

/*定义、只抽取了很多类的方法的声明，为了保证不出问题，方法声明用abstract修饰。
抽象类的特点
A：一个类如果有了抽象方法，那么这个类必须是抽象类。抽象类里边可以没有抽象方法。
B：抽象类是不能够被实例化的。不能够创建对象的。
C：如果一个类继承抽象类，那么，它要么重写抽象类中的所有抽象方法，要么本身也是抽象类。
抽象类的成员特点：
A：成员变量：子类可以直接继承抽象类中的成员变量。(抽象类中的成员变量可以和以前是一样的)
B：成员方法：抽象类中分为两种方法， * 一种是抽象方法，这种方法在子类中必须要被实现。 * 一种是普通的方法。可以被子类直接继承使用。
C：构造方法：抽象类不能被实例化，那么它有构造方法吗?抽象类是class，那么它就有构造方法。它的构造方法有用吗？有，为了让子类实例化的时候使用。*/
public static void main(String[] args) {

//Animal a = new Animal();
//a.eat();

Animal2 a = new Cat2();
a.eat();

Cat2 c = new Cat2();
c.eat();

Dog d = new Dog();
d.eat();

System.out.println(c.num);//子类可以直接继承父类的成员变量
}
}

abstract class Animal2 {						//抽象类,抽象类中有构造方法用来给子类实例化使用
int num = 10;
public abstract void eat();				//抽象方

public void sleep() {					//抽象类是不能被实例化(创建对象)
System.out.println("动物睡觉");       //抽象类中可以有非抽象的方法
}

public Animal2() {

}
}

class Cat2 extends Animal2 {
public Cat2(){//这是系统默认给的其中的super会访问父类构造方法
super();
}
public void eat() {
System.out.println("吃鱼");//子类必须重写父类所有抽象方法
}
}
/*抽象关键字abstract不可以和哪些关键字共存？
private
私有的，外部直接无法访问。子类也同样无法访问,为了不让子类看到
abstrac修饰的方法就是为了让子类继承并重写的
static
那么这个时候抽象方法就可以可以通过类名调用，但是这样是没有意义的。
final
final修饰的方法不能被重写。所以它和abstract冲突。
C：抽象类中可不可以没有抽象方法？
可以。如果这么做只有一个目的不让你创建这个类的对象*/

接口

public static void main(String[] args) {
Demo d = new Demo();
d.print();
//System.out.println(Inter.num);
}
}
/*接口特点
a:接口用关键字interface表示
interface 接口名 {}
b:类实现接口用implements表示
class 类名 implements 接口名 {}
c:接口不能实例化
那么，接口如何实例化呢?
按照多态的方式来实例化。
d:接口的子类
a:可以是抽象类。但是意义不大。
b:可以是具体类。要重写接口中的所有抽象方法。
接口成员特点
成员变量；只能是常量，并且是静态的。
默认修饰符：public static final
建议：自己手动给出。
构造方法：接口没有构造方法。
成员方法：只能是抽象方法。
默认修饰符：public abstract
建议：自己手动给出。*/

interface Inter {
public static final int num = 10;				//接口中所有的变量都是常量

public abstract void print();					//接口中所有的方法都是抽象的
}

class Demo implements Inter {
public void print() {							//重写接口中的方法,权限必须是public
System.out.println("1111111111111");
}
}

public static void main(String[] args) {
/*DemoE d = new DemoE();
d.method();
d.show();*/

DemoG d = new DemoG();
}
}

/*
类与类,类与接口,接口与接口的关系
A：类与类：只能是单继承。 extends
B：接口与接口：可以是单继承，也可以是多继承。 extends
C：类与接口：可以是单实现，也可以是多实现。 implements
*/

interface DemoA {
public void show();
}

interface DemoB {
public void method();
}

abstract class DemoC {
public abstract void print();
}

/*class DemoD extends DemoC {				//类与类之间是继承关系,只能单继承
}*/

/*class DemoE implements DemoA,DemoB {		//类与接口直接是实现关系,既可以单实现也可以多实现
public void show() {
System.out.println("show");
}

public void method() {
System.out.println("method");
}
}*/

interface DemoF extends DemoA,DemoB{		//接口和接口直接是继承关系,既可以单继承也可以多继承

}

class DemoG implements DemoF {
public void show() {
System.out.println("show");
}

public void method() {
System.out.println("method");
}
}
/*接口和抽象类的区别：
A：抽象类只能被单继承；接口可以被多实现。
B：
抽象类中的成员：
成员变量:可以是常量，也可以是变量。
成员方法:可以是抽象的，也可以是非抽象的。
构造方法:虽然不可以创建对象，但是可以给子类实例化用。
接口中的成员：
成员变量：只能是常量。默认修饰符 public static final
成员方法：只能是抽象的。默认修饰符 public abstract
C：抽象类中定义的是体系结构中的共性的内容。接口中定义的是对象的扩展功能。
D：抽象类被继承表示的是："is a"的关系。xx是yy中的一种。接口被实现表示的是: "like a"的关系。xx像yy中的一种。*/

成员内部类

public static void main(String[] args) {
//Inner i = new Inner();
//i.print();
//外部类名.内部类名 对象名 = 外部类对象.内部类对象;
//Outer.Inner o = new Outer().new Inner();
//o.print();

Outer o = new Outer();
o.method();
}
}
/*定义,:在一个外部类中有成员变量和成员方法,那么成员内部类就是把整个一个类当成了外部类的成员对待了
访问方式:内部类访问外部类,内部类可以直接访问外部类,包括私有成员,因为内部类拥有外部类的引用是类名.this*/

class Outer {							//外部类
//成员内部类
private int num = 10;
private class Inner {				//内部类,存放位置:在外部类里,在外部类的成员方法外
public void print() {			//内部类的成员方法
System.out.println(Outer.this.num);
}
}

public void method() {
Inner i = new Inner();			//创建内部类对象
i.print();						//调用内部类方法
}
}

静态内部类

public static void main(String[] args) {
//外部类名.内部类名 对象名 = 外部类名.内部类对象;
/*Outer2.Inner oi = new Outer2.Inner();
oi.print();

Outer.Inner.method();*/

}
}
/*定义,就是在成员内部类的基础上加上static*/
class Outer2 {
static class Inner {
public void print() {
System.out.println("Hello World!");
}

public static void method() {
System.out.println("method");
}
}

/*class Inner2 {							//非静态的成员内部类中不可以定义静态的成员
public static void run() {
System.out.println("run");
}
}*/
}

局部内部类

public static void main(String[] args) {
//Outer o = new Outer();
//o.method();

Outer1 o = new Outer1();//方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
o.method();
}
}
/*定义,在外部类成员方法中定义的内部类,他更像局部变量*/
class Outer1 {										//外部类
public void method() {							//外部类的成员方法
final int num = 10;// 局部内部类访问局部变量必须用final修饰，被它修饰后进方法区的常量池
class Inner {								//局部内部类
public void show() {					//局部内部类中的成员方法
System.out.println(num);
}
}

Inner i = new Inner();//方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
i.show();
}

}

匿名内部类

public static void main(String[] args) {
Outer2 o = new Outer2();
o.method();
}
}

interface Inter {
public void show1();
public void show2();
}
/*前提：内部类可以继承或实现一个外部类或者接口。
格式为：new 外部类名或者接口名(){覆盖类或者接口中的抽象的方法，(也可以自定义内容。)}
简单理解：就是建立一个带内容的外部类或者接口的子类的匿名对象。
* 本质是一个继承了该类或者实现了该接口的子类匿名对象
* 通常在使用方法是接口类型参数，并该接口中的方法只有一个时，可以将匿名内部类作为参数传递。*/
class Outer {
/*class Inner implements Inter {				//有名字的内部类实现外部接口
public void show1() {
System.out.println("show1");
}

public void show2() {
System.out.println("show2");
}
}

public void method() {
Inter i = new Inner();						//父类引用指向子类对象
i.show1();
i.show2();
}*/

public void method() {
/*new Inter() {
public void show1() {
System.out.println("show1");
}

public void show2() {
System.out.println("show2");
}
}.show1();

new Inter() {
public void show1() {
System.out.println("show1");
}

public void show2() {
System.out.println("show2");
}
}.show2();*/

Inter i = new Inter() {					//匿名内部类最好重写一个方法的时候使用
public void show1() {
System.out.println("show1");
}

public void show2() {
System.out.println("show2");
}
};
i.show1();
i.show2();
}