黑马程序员_面向对象2

最新推荐文章于 2022-08-06 18:57:45 发布

原创最新推荐文章于 2022-08-06 18:57:45 发布

· 置顶 · 386 阅读

版权

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

final:
继承后，子类的方法可以和父类的方法声明一样，这样就重写了父类的功能。
但是，有些情况下，某些方法是只能被父类实现，子类不应该重写该方法。
针对这种情况，java就提供了一个关键字：final
1.final修饰方法。。。被final修饰的方法是不能被重写的。
2.final修饰类。。。。如果说某一个类被final修饰的话，那这个类就是最终类，最终类是不可以有儿子的。
换句话说就是：被final修饰的话是不可以被另外一个类继承的。
3，被final修饰的成员变量，是不允许修改值得，换句话说：被final修饰的变量之后就是一个常量了，就不允许
再改变它的值
1。被final修饰的方法是不能被重写的。

class father{
	public final void  show(){
		System.out.println("这是我自己独有的一种方法");
	}
}
class son extends father{
	/*public void show(){
		System.out.println("这种方法不一定就是你自己的");
	}
	*/
}
class finalceshi{
	public static void main(String[] args){
		son s=new son();
		s.show();
	}
}

怎么定义常量？
第一：字面值常量
10，"hello"
第二：自定义常量
final int X =10；
用第二种方法定义常量的时候一定记得是大写！！！
多态：
同一个对象，在不同时刻表现出状态。叫做多态。
多态的条件：
父类或者接口的引用指向或者接收自己的子类的对象。满足这一条才叫多态
第一必须有继承，第二父类的方法必须被重写，因为只有这样才可调用子类的方法。因为这样才有意义。

第三就是以上的一条。

多态的特点：
father f=new father（）；
成员的变量。
编译看左边，运行看右边。
成员的方法。
编译看左边，运行看右边。（因为方法的重写关系）
编译的时候看左边
多态的弊端：
不能访问子类的特有功能。
假设现在必须要访问子类的特有功能？如何？
多态的成员变量和成员方法：
成员变量：编译看左边，运行看左边。
成员方法：编译看左边，运行看右边。
成员静态方法：编译看左边，运行看左边，和编译一样。（因为静态的方法不叫方法重写。overload叫重载）
把两个类中共有的部分提取出来，定义在一个类中，这个类就叫做抽象类；
比如下边这两个类；

class a{
	public void show(){
		System.out.println("第一个类");
	}
}
class b{
	public void show(){
		System.out.println("第二个类");
	}
}

这连个类中共有的部分只有方法声明，方法体去不相同，这个时候我们把他们共有的部分提取出来，
构成一个新类，这就是抽象类。
class c{
public void show(); //这个地方没有花括号。。。。
}
于是这就是抽象类，但是此时以上这种写法就是错的。
应写为：
class c{
public void abstract show(); //此时关键字是extends，写在void
}
这时public void abstract show 就是抽象的方法，但是一个类中如果含有抽象方法的话，那这个类就必须
是抽象类,于是必须在类的前面加上extends。
但是同时以上这种写法也是错误的：
最后正确的是：
abstract class{
public abstract void show();
}
抽象就是将两个类中共有的共性提出来，比如说：狼和狗都是犬科目
抽象类不可以被实例化，也就是不可以用new创建对象。
原因如下：1.
抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。
例如：犬科是一个抽象的概念，真正存在的是狼和狗。
2.而且抽象类即使创建了对象，调用抽象方法也没有意义.
抽象方法必须是没有方法体的。
抽象类的特点就是：
1.某个方法是抽象方法的话，它所在的类也必须是抽象类。同时抽象方法和抽象类必须用abstract来修饰。
2.抽象类和抽象方法必须用abstrast来修饰。
3.有抽象方法的类必须是抽象类，但是抽象类不一定有抽象方法
4.类继承抽象类的时候：有两种解决方案：
（1）要么让子方法来实现抽象类中所有抽象方法。这个时候子类方法方法不能写抽象类。
（2）或者是子类中也定义为抽象类。
5.抽象的类不能实例化，不可以创建对象。
但是如果抽象类不能实例化怎么用？
通过子类的实例化来实现。
抽象类的好处：
A：抽象类中的非抽象方法同样提高了代码的复用性。
B: 要求子类必须做某些事情。（必须要实现抽象类的方法，或者是子类也是抽象方法）
抽象方法不能实例化，不可以创建对象，但是可以有构造方法。
用于子类调用父类的数据的初始化。代码实例如下：
这个地方继承，前面学到的，但是给忘记了。
所谓继承，就是父亲已经具有的方法，但是子类没有的方法，建立了子类的对象，直接调用父类的方法可以调用！
但是如果建立了父类的对象，如果调用子类的就不可以！这就叫继承！
如果说：父类和子类的方法有重名的，如果说是有重名的那就是：重写！
父类中有的方法，但是子类中没有，那子类就是继承！
抽象类中是否有构造方法？
有，用于子类访问父类的数据的初始化！
抽象类中可不可以没有抽象方法？
可以。就是为了不让别人创建对象！
抽象关键字abstract不可以和那些关键字共存？
private：私有的意思，私有的方法不能被重写，而abstract的方法要求被重写。冲突。
final：最终的意思，最终方法不能被重写，而abstract要求被重写冲突。
static：假设一个抽象方法可以被静态修饰。那么，我们就可以通过类名调用一个没有方法体的类，没有意义！！
static是一个静态的方法，abstract没有方法体，静态的可以用类名.方法名来调用，调用一个没有方法体的
类是没有意义的！
抽象类中
成员变量：既可以是变量，也可以常量；
构造方法：可以是构造方法；
成员方法：既可以抽象的，也可以不是抽象的！
抽象类中可以有抽象方法，也可以由非抽象方法，如果一个类中有抽象方法，那这个类就必须定义为一个
抽象类。这个类中可以有抽象方法，也可以有非抽象方法。
但是如果一个类中只能有抽象方法，那这个类就是接口。接口就是特殊的抽象类！！！
接口是如何表示的？interface！
如何定义一个接口的！？
class xxx{
方法体；
}
如果是依照着定义一个类模仿的话那就是：
interface 接口名{
抽象方法1；
抽象方法2；

抽象方法3；

}
接口的特点：
A:接口用关键字Interface定义！
B:类实现接口都是用：implement来表示！
有一点必须要提到的就是接口+impl表示的是一个实现类。
C:类实现接口可以用两种方法？
要么实现接口中的所有抽象方法；
要么本身就是抽象类。

1.interface A{
public void show();
}
abstract class B implement A{}
2.interface A{
public void show();
}
 class B implement A{
public void show(){
System.out.println("这是一个类实现了抽象方法");
}
}

多态一共有三种：
第一种：具体类多态；
第二种：抽象类多态；
第三种：接口类多态；

接口不可以实例化，因为抽象类就不可以实例化，接口比抽象类还抽象，当然不可以实例化；
接口的四个特点：
第一个特点：接口必须要用interface来定义
第二个特点：类实现接口必须要用关键字implements来是实现；
第三个特点：类实现接口必须要用两种方法：
第一个方法：必须实现接口的类是抽象类；
第二个方法：实现接口的类中，必须将接口的每个方法都实例化；
第四个特点：接口不能实例化；
多态的体现：
A:具体类的多态；

class fu{
public void show(){}
}
class zi extends fu{
public void show(){}
}
  fu f=new zi();

B:抽象类的多态；
只不过是在原本的具体类的多态中父类的开头加上了abstract；

  abstract class fu{
public void show(){}
} 
class zi extends fu{
public void show(){}
} 
C:接口类的多态；
  interface fu{
public void show(){}
}
class zi implements fu{
publci void show(){}
}

fu f=new zi();

一定记住一点，抽象类都是无法实例化的！
在多态中一共有三种：
变量时：编译看左边，运行看左边；（而继承访问成员变量的时候就要用到this ， super 等关键字）
成员变量时：编译看左边，运行看右边，（帮助记忆：主要是因为方法得到了重写）
但是成员方法没有重写的话，那就是编译看左边，运行看右边；
构造方法时：编译的时候不知道，要访问父类的有参构造，使用了super（）关键字
这个时候子类和父类的有参构造都访问而输出。
（这个时候和继承是一样的效果）
如果是不访问，父类的有参构造，系统自动访问父类的无参构造，
这个时候子类和父类的无参构造都访问输出。
（这个时候和继承是一样的效果）
总之，多态的多态和继承关于构造方法是一样的！
多态的前提：
A:要有继承或者实现关系；
B:要有方法重写；
C:要有父类引用或者父接口引用指向子类对象；
抽象类可以有变量，可以有常量，可以有抽象方法，也可以由非抽象方法；
接口中必须都是抽象方法，而且不可以实例化！
例如接口的实现类中的方法，类似于父类中方法重写。（助记）

interface fu{
int a=29;   （接口里的变量默认的都是有final关键字的，不仅如此，接口中变量都带有默认修饰符：public static final也就是说接口里没有变量）           
final int b=23;
public  abstract void show();    （这个地方接口里的方法必须都是抽象方法）
} 
class zi implements fu{
public void show(){               （这里的方法实现就是类似于 继承里的方法重写）
System.out.println(a);
System.out.println(b);
}
}
class jiekou{
public static void main(String[] args){
fu f=new zi();
f.show();
}
}

接口里的特点：
1.接口中的变量，都是带有默认关键字final的，也就是说接口中是没有变量的，只有常量；
接口中的变量都是带有默认修饰符号：public static final 的
定义的时候可以有两种方法：
1.int a=2；（这个时候的变量，其实前面有默认的final关键字的）（这个时候接口的变量可以通过父类指向子类的对象来调用，
也可以通过类名来调用的）
2.final int a=2；
（这个定义就是常量，这是接口中官方定义方法）
2.构造方法
接口是不允许有构造方法的！
3.成员方法
抽象类中的方法必须都是抽象方法。也就是说，抽象接口中的方法都带有默认的修饰符：public abstract
推荐在定义抽象接口的时候，把应该带上修饰符都加上。

抽象类中可以带有构造方法；接口中不可以带有抽象方法；
抽象类中可以带有抽象方法，也可以带有非抽象方法；接口中方法必须都是抽象方法；
抽象类可以没有抽象方法；
1.接口是对外暴露的规则；
上课的时候举了一个关于插排的例子，只有两个头和三个头的插口，不可以有其它的！
2.接口是程序的功能扩展；
例子：我带有外界键盘；
3.接口的出现降低了耦合（类和类的关系）性
我们写程序的时候，一定降低类和类的关系；继承的关系就是提供了代码的复用性，缺点就是提高了代码的耦合性
接口就是降低了代码的耦合性
4.接口可以用来多实现。
1.类与类的关系；
继承关系；java只支持单继承，不支持多继承，但支持多层继承，
2.类与接口的关系；
实现关系，可以单实现，可以多实现！
并且还可以在继承一个类的同时实现多个接口。

interface Inter1{
public abstract void  show();
}
interface Inter2{
public abstractvoid method();
}


class fu{
public void collage(){
System.out.println("fu()");
}
}


class zi extends fu implements Inter1,Inter2{    //实现关系，可以单实现，可以多实现！并且还可以在继承一个类的同时实现多个接口。
public void show(){
System.out.println("这是一个show方法");
}
public void method(){
System.out.println("这是一个method方法");
}



}
class cheshi3{
public static void main(String[] args){
fu f=new zi();
f.show();
f.method();

}
}

3.接口与接口的关系；
继承关系！可以单继承，也可以多继承！
如果某个a接口继承了一个b接口和c接口，
如果是要实现a接口的时候，必须a接口和b接口和c接口都重写！
面试题：java中只有单继承？
错！java中如果类与类是单继承的
java中接口和接口是可以多继承的
抽象类和接口的区别？
1.成员区别：
抽象类：
成员变量：可以是常量，也可以是变量。
构造方法：有。用于子类访问父类数据的实例化使用。
成员方法；可以是抽象的，也可以是非抽象的。
接口：
成员变量：必须都是常量的；默认的修饰符：public static final
构造方法：没有。
成员方法：必须都是抽象的！默认的稀释符 public void abstract（这个默认的修饰符在JDK 8 是不允许的！）
2.关系区别；
类与类的关系：
继承关系，只能是单继承，不可以多继承。可以多层次继承
类与接口的关系：
实现关系，可以但实现，也可以多实现。
并且还可以在继承一个类的同时实现多个接口。
接口与接口的关系：
继承关系，可以是单继承，也可以是多继承。
3.设计理念区别；
抽象类被继承体现的是：“is a”的关系，抽象类中定义的是该继承体系的共性功能。
接口被实现体现的是：“like a”的关系，接口中定义的是该继承体系的扩展功能。
例如：
具体事务：
乒乓球运动员和乒乓球教练；
篮球运动员和篮球教练；
为了出国交流，跟乒乓球有关的人员要学习英语。
用所学的知识分析：
有那些类？接口？抽象类？
分析：
从具体到抽象；
实现：
从抽象到具体；
应用：
用的是具体的内容；

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------