和java谈恋爱：本色的她 （抽象类、接口) ---尚硅谷 -课程笔记

抽象类：

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计的非常抽象，以至于它没有具体的实例，这样的类叫抽象类。

less_04 

/*

  *abstract:抽象的

  *1. 可以用来修饰一个类：对应的类叫抽象类

1)抽象类不可实例化

        2)具体的类通过继承抽象类的方式，创建子类的实例。

      3)当子类继承抽象类之后，由子类重写抽象类中的 方法

      4）子类必须重写抽象类机器父类的所有的抽象方法，才能实例化

   

  *2.还可以用来修饰类中的方法，对应的方法叫抽象方法

        1）抽象方法不在提供方法体

         2）抽象方法所在的类，那一定是抽象类。抽象 类里不一定有抽象方法。

  

  * 不能用abstarct修饰属性、私有方法、构造器、静态方法、final的方法。 

  *抽象类可以定义构造器！-------》接口是没有构造器的

*/

abstract class Creator{

   public void breath();

}

abstract class Person{

 private String name;

 private int age;

 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 asbstract void talk();

//{System.out.println("人说话");

//}

public asbstract  void work(){

 system.out.println(“人工作");

}

class Worker extends Person{

public void talk()

{ SYstem.out.println("学生讨论问题!");

} 

 public void work()

{

 system.out.println(”工人讨论技术问题！“);

}

class Student extends Person{

public void talk()

{ SYstem.out.println("学生讨论问题!");

} 

 public void work()

{

 system.out.println("学生不工作");

}

public calss TestAbstract{

//Person p = new Person();

    p.talk();

   p.work();

 Person p1 = new Student();

p1.talk();

p1.work();

}

}

//模板方法的设计模式：执行代码一段代码所花费的时间

abstract class Templete{

public abstarct void code();

       pulbic void costTime()

{ long start = system.currentTImeMillis();

  code();

  long end = System.currentTimeMillis();

 System.out.println(”所花费的时间为:“ + (end - start)):

}

class subTemplent extends Templete{

public void code(){

for(int i = 2;i < 100000;i++)

  boolean flag = false;

for(int j = 2; j <= math.sqrt(i)j++)

if(i %j == 0 ){

flag = true;

  break;

} }

if(!flag){

System.out.println(i);

}

flag = false;

}

}

publci class TestTemplete

}

接口抽象类的一种。

有时必须从几个类中派生出一个子类，继承他们所有的属性和方法，但是java不支持多重继承。

/*

*1.interface 接口名{

*//有常量

*都是声明为public static final 的

*//有抽象方法

*public abstract 的

}

*

*2.接口定义了一种功能。类通过实现接口的形式，就具有了接口的这种功能

3.格式：class B extends c implements A

  一个类可以实现多个接口

接口直接可以继承，而且是支持多继承的！

4.接口不可以实例化。同事接口是没有构造器的。

*/

public interface  A{

 //String name;

 public static final double PI = 3.14;

/*public static final*/  int I = 3;

public abstract void method1();

public abstract void method2();

//public void show(){

//}

interface D{

 void method3();

}

interface F{

}

interface E extends D,F{}

class c {

}

class B extends c  implements A,D{

@Override

public void method1(){

Sysmtem.out.println("hello");

}

@Override

public void method2(){

Sysmtem.out.println("atguigu");

}

public void method3(){

Sysmtem.out.println("光棍节快乐！");

}

}

public class TestInterface{

}

public class TestUSB{

public static void main(){

 computer c = new computer();

 c.useUsb()new Print()); //多态

c.useUsb(new USB(){  //可以理解为实现了USB接口的一个匿名类的对象

 @Overrid

 public void Start(){

 System.out.Println()"";}

 @public void stop(){}

});

 }

}

interface USB{

void Start();

   void stop();

}

class Computer{

 pulbic void useUsb(USB usb)

{

 usb.start();

System.out.println(""USB工具开始运行=======);

usb.stop();

}

class Print implenments USB{

 

@OVerride 

public void start(){

 System.out.println(U盘启动)"":

}

public void start(){

 System.out.println()"":

}

}

}

class Flash implements USB{

@OVerride 

public void start(){

 System.out.println(U盘启动)"":

}

public void start(){

 System.out.println()"":

}

}

代理模式（proxy)为其他对象提供一种代理以控制对这个对象的访问。

工厂方法：

FactoryMethod模式

public clas TestFactory{

pulbic static void main()

{

 IWorkFactory  if1 = new studentWorkFactory();

if1.getWork().doWork();

 IWorkFactory  if1 = new TeacherWorkFactory();

if2.getWork().doWork();

}

interface IWorkFactory{

work getWork();

}

class studentworkFactory implements IWorkFactory

{

 public work getWork(){

return new student();

}

}

class TeacherWorkFactory implements IWorkFactory{

public work getWork(){

return new Teacher();

}

}

interface Work{

 public abstarct void dowork();

}

class studentwork implements work{

 public void doWork(){

 System.out.println("学生学习");

}

}

class TeacherWork implements work{

 public void doWork(){

 System.out.println("老师批改作业");

。单例模式：

final

.........