继承基本概念
extends,很好理解嘛,就是儿子继承父亲的属性;所以父类有什么,子类就有什么属性。
继承实现的限制问题
规范:只能一次继承一个父类!即在过程中一对一继承!
子类实例化的过程
当使用new关键字实现类的时候,先调用父类的构造器再调用子类构造器。(因为对象初始化就是构造函数的调用过程)
方法的覆写
private<default<public private——>public default——>public 就是直接在子类中定义同样的方法名并且扩大或者不动(父类>=子类)方法访问权限,进而具体实现。 private——>default不算是方法的覆写
super关键字
代表父类的意思,和this的意义差不多吧,但是需要注意的是,this在子类中找不到对于的方法和变量,将去父类中寻找。
package com.Example.chapter05;
/**
1. @author Administrator
2. @function : 继承的初步理解
*/
public class ExtendsDesign {
public static void main(String[] args) {
Student guangwei=new Student();
guangwei.setName("光唯");
guangwei.setAge(23);
guangwei.setSex("男");
System.out.println(guangwei.getName()+"\t\t"+guangwei.getAge()+"\t\t"+guangwei.getSex());
}
}
class Person{
private String name;
private int age;
private String sex;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
class Student extends Person{
}
- 抽象类abstract
package com.Example.chapter05;
/**
* @author Administrator
* @date : 2017年3月26日 下午9:53:27
* @function : 抽象类的了解
*/
public class AbstractDesign {
public static void main(String[] args) {
Demo2 A=new Demo2();
A.outPut();
}
}
abstract class Demo{
private int age=0;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
/*************抽象类********************/
public abstract void outPut();
}
class Demo2 extends Demo{
@Override
public void outPut() {
// TODO Auto-generated method stub
System.out.println("Demo2继承抽象类Demo去实现实例化");
}
}
抽象类相当于“模板”,提供一个模板供子类去实现。
1. 有抽象方法的类必须是抽象类
2. 抽象类和抽象方法都必须用abstract修饰
3. 抽象方法不能具体实现
4. 抽象类需要子类去实例化
我们通过了解抽象类来和普通类进行区别一下,抽象类无非是需要abstract进行修饰,并且有抽象方法的类一定是抽象类。抽象类不一定必须要有抽象方法。
4.接口interface
接口是一种特殊的类;
package com.Example.chapter05;
/**
* @author Administrator
* @date : 2017年3月26日 下午10:07:55
* @function : 接口的理解
*/
public class InterfaceDesign {
public static void main(String[] args) {
Test t=new Test();
System.out.println(t.getAge()+"\t"+t.getSex());
}
}
class Test implements Demo1,Demo2{
@Override
public int getSex() {
// TODO Auto-generated method stub
return sex;
}
@Override
public int getAge() {
// TODO Auto-generated method stub
return age;
}
}
interface Demo1{
public static final int age=20;
public abstract int getAge();
}
interface Demo2{
public static final int sex=0;
public abstract int getSex();
}
在接口中,变量必须为全局(static)常量(final);
方法必须为抽象方法;与继承不同的是可以多重接入接口;(最重要的是常量和方法默认和要求必须是public权限)
5. 对象的多态性(——–>多种形态)
1.方法的覆写
(要把握覆写和实现的区别,抽象类不能叫做覆写)
2.上下转型
对象是new出的在于堆内存中部分,
对象向上转(数据类)型:父类类型 标识符=子类对象
对象向下转(数据类)型:子类类型 标识符=(子类类型)父类对象(显示转换类型)
对象在向下转型必须先向上转型;
package com.Example.chapter05;
/**
* @author Administrator
* @date : 2017年3月27日 上午11:29:15
* @function : 主要是看重多态性的表现。上转型和下转型
*/
public class DifferentVisionDesign {
public static void main(String[] args) {
A a=new B();
a.outPut();
B b=(B)a;
b.outPut();
}
}
class A{
public void outPut(){
System.out.println("A类在此"+"\n---------------------------");
}
}
class B extends A{
public void outPut(){
System.out.println("B类在此"+"\n---------------------------");
}
}
常见设计模式
1.首先无疑是抽象类和接口的使用,他们先制定标准再给子类(extends,inmplements)具体实现。 2.制定标准
package com.Example.chapter05;
/**
* @author Administrator
* @date : 2017年3月27日 上午11:52:55
* @function : 制定标准
* 1.电脑接收USB接口
* 2.USB分为盘和打印机
*/
public class DesignMode {
public static void main(String[] args) {
Computer worker=new Computer();
worker.start(new UDevice());
worker.start(new Printer());
}
}
class Computer{
public void start(USB device){
device.work();
device.finish();
}
}
interface USB{
public abstract void work();
public abstract void finish();
}
class UDevice implements USB{
@Override
public void work() {
// TODO Auto-generated method stub
System.out.println("U盘开始工作"+"\n--------------------------");
}
@Override
public void finish() {
// TODO Auto-generated method stub
System.out.println("U盘停止工作"+"\n--------------------------");
}
}
class Printer implements USB{
@Override
public void work() {
// TODO Auto-generated method stub
System.out.println("打印机开始工作"+"\n--------------------------");
}
@Override
public void finish() {
// TODO Auto-generated method stub
System.out.println("打印机停止工作"+"\n--------------------------");
}
}
3.工厂模式(产生一个工厂类,在里面拿具体实例)
问题展示:
package com.Example.chapter05;
/**
* @author Administrator
* @date : 2017年3月27日 下午12:21:39
* @function : 工厂类理解
*/
public class FactoryDesign {
public static void main(String[] args) {
Personk instance=null;
instance=new man();
instance.say();
instance=new woman();
instance.say();
}
}
class Personk{
public void say(){
}
}
class man extends Personk{
@Override
public void say() {
// TODO Auto-generated method stub
System.out.println("男人说话女人不要插嘴");
}
}
class woman extends Personk{
@Override
public void say() {
// TODO Auto-generated method stub
System.out.println("女人说话男人不要插嘴");
}
}
所以很容易发现哦,在主方法中,每次去实例化一个类都要单独去实现才能调用方法;而且这个实例完全是可以使用类似于单例模式(解决构造方法私有化);
package com.Example.chapter05;
/**
* @author Administrator
* @date : 2017年3月27日 下午12:21:39
* @function : 工厂类理解
*/
public class FactoryDesign {
public static void main(String[] args) {
Personk instance=null;
instance=new Factory().getInstacne("man");
instance.say();
}
}
class Factory{
public Personk instance=null;
public Personk getInstacne(String classname){
if(("man").equals(classname)){
this.instance=new man();
}else if(("woman").equals(classname)){
this.instance=new woman();
}
return this.instance;
}
}
class Personk{
public void say(){
}
}
class man extends Personk{
@Override
public void say() {
// TODO Auto-generated method stub
System.out.println("男人说话女人不要插嘴");
}
}
class woman extends Personk{
@Override
public void say() {
// TODO Auto-generated method stub
System.out.println("女人说话男人不要插嘴");
}
}
4.代理模式
Object类详解
包装类的作用以及自动装箱和拆箱的操作
- 匿名内部类
final关键字
就此定义为终结者。end of everything!一经定义不得修改!他可以用来修饰类。
11.instanceof关键字
判断哪个对象是否属于哪个实例; 对象 instanceof 类名 ——>boolean类型值