Java Study For Seven Day( 面向对象三)

继承

class Person
{
 String name;
 int age;
}
class Student extends Person
{
 
 void study()
 {
  System.out.println("good study");
 }
}
class Worker extends Person
{
 void work()
 {
  System.out.println("good work");
 }
}
class ExtendsDemo
{
 public static void main(String[] args)
 {
  
 }
}

1.把很多的类的相同的特征和行为进行抽取，用一个类来描述。让多个类和这个类产生一个关系

这样的话多个类可以省略很多的代码，这个关系就是继承，Java中关键字extends来表示。

　　2.继承的体系结构

　　　　A.多个具体的对象，不断的向上抽取共享的内容，最终形成了一个体系，叫做继承体系。

　　　　B.继承体系的学习和原则

　　　　　　学习顶层的内容。原因是它是体系的共性内容

　　　　　　创建子类使用。也就是使用底层的具体对象

　　 3.继承的特点

　　　　Java中只能是单继承，没有多继承这一说法。

　　　　Java中可以多层(重)继承

　　 4.继承的好处

　　　　继承的出现提高了代码的复用性

　　　　继承让类与类之间产生了关系，是多态的前提条件

　　　5.子父类中的成员间的关系

　　　　 A.成员变量

　　　　　　在子类中方法中使用一个变量时，首先，在方法的局部变量中找这个变量，有则使用

否则，在本类中找成员变量，有则使用，否则，在父类中找成员变量，有则使用，否则报错。

　　　　 B.成员方法

　　　　　　　用子类对象使用方法时，首先，在子类中找这个方法，有则使用，否则，在父类中

找这个方法，有则使用，否则报错。

　　　　　重写和重载的区别

　　　　　　重载:在同一个类中，方法名相同但是参数的列表不同，并且返回类型不能作为判断的依据

　　　　　　重写:在不同类中(子父类中)，方法声明(返回类型、方法名称、参数列表都要一致)。

　　　　　重写需要注意:

　　　　　　子类方法的访问权限要大于等于父类方法的访问权限

　　　　　　静态只能重写静态的，一般不会出现

　　　　　构造方法

　　　　　　子列实例化过程

　　　　　　　　子类创建对象时，会先去创建父类的的对象，默认是去调用父类的五参构造方法

　　　　　　　　注意:子类构造方法中，默认第一行是super，原因是因为它继承父类的成员使用，使用前

这些成员必须初始化，因而，会先创建一个父类的对象，所以当父类没有无参构造函数时，必须使用this或是super

调用其它的构造函数。

　　　6.this和super的区别

　　　　this代表是本类的对象的引用，而super代表的是父类的存储空间

class Fu
{
 private int num =4;
 void sperk()
 {
  System.out.println("vb");
 }
}
class Zi extends Fu
{
 int num =5;
 void show()
 {
  System.out.println(super.num);
 }
 void speak()
 {
  System.out.println("java");
 }
}

class ExtendsDemo1
{
 public static void main(String[] args)
 {
  Zi zi = new Zi();//new一对象加载子类.class文件前先加载父类.class文件
  System.out.println(zi.num+"..."+zi.num);
  zi.show();
 }
}

class Tel
{
 void show()
 {
  System.out.println("number");
  
 }
}
class NewTel extends Tel
{
 void show()
 {
  System.out.println("name")
  //System.out.println("number");
  super.show();
  System.out.println("picture");
 }
}

final关键字

　　1.最终的意思，可以用于修饰类、方法、变量

　　2.final修饰的类不能继承，修饰的方法不能重写、修饰的变量是一个常量，只能被赋值一次

内部类只能访问被final修饰的局部变量。

class Demo
{
 public static final int x =3;//全局常量。
 final  void show1()
  {
   final int y =4;//
   y = 4;//会挂 进行了第二次赋值
   
   final double pai =3.14;//给3.14这个数据起个名字，方便阅读
    
  }
 void show2(){}
 
}
class SubDemo extends Demo
{
 void show1(){}
}
class FinalDemo
{
 public static void main(String[] args)
 {
  
 }
}

抽象类

　　1.多个类有相同的方法声明，但是方法体不一样，此时可以考虑把方法声明进行抽取，让子类继承后去

实现方法体，没有方法体，从而需要用抽象标志下，关键字是abstract

　　2.抽象类

　　　　该方法称为抽象方法，包含抽象方法的类就是抽象类

　　3.抽象类的特点

　　　　抽象类和抽象方法都要用abstract进行修饰

　　　　抽象类不能被实例化

　　　　抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类

　　4.抽象类中的数据特点

　　　　成员变量

　　　　　　抽象类中可以有常量，也可以有变量

　　　　成员方法

　　　　　　抽象类中可以有抽象方法，也可以有非抽象方法

　　　　构造函数

　　　　　　抽象类是一个类，所有有构造函数，但是本身不能实例化，但是可以给子类实例化使用

　　5.抽象类中的问题

　　　　A.抽象类中有构造函数不能被实例化但是可以供子类实例化

　　　　B.抽象关键字abstract不可以和那些关键字共存？

　　　　　　私有的内容继承不到，所以不能重写但是abstract修饰的方法要求被重写所以冲突

final修饰的方法不能被重写也冲突，static假如一个抽象方法能通过static修饰，那么这个方法，就可以直接通过类名调用。而抽象方法是没有方法体的，这样的调用无意义。所以，不能用static修饰。

　　　　C.抽象类中可不可以没有抽象方法？

　　　　　　抽象类中没有抽象方法的作用，只是为了不让别的类建立该抽象类对象。这个在awt中有体现。

class Demo
{
 public static final int x =3;//全局常量。
 final  void show1()
  {
   final int y =4;//
   y = 4;//会挂 进行了第二次赋值
   
   final double pai =3.14;//给3.14这个数据起个名字，方便阅读
    
  }
 void show2(){}
 
}
class SubDemo extends Demo
{
 void show1(){}
}
class FinalDemo
{
 public static void main(String[] args)
 {
  
 }
}
*抽象类练习

class
{
}
class Employee
{
 private String name;
 private String id;
 private double pay;
 Employee(String name,String id,double pay)
 {
  this.name = name;
  this.id = id;
  this.pay = pay;
 }
 public abstract void work();
 
}
class Manage extends Employee
{
 private int bonus;
 Manager(String name,String id,double pay,int bonus)
 {
  super(name,id,pay);
  this.bonus = bonus;
 }
 public void work()
 {
  System.out.println("manage work");
 }
}
class Pro extends Employee
{
 Pro(String name,String id,double pay)
 {
  super(name,id,pay);
 }
 public void work()
 {
  System.out.println("pro work");
 }
}
class
{
 public static void main(String[] args)
 {
  
 }
}

接口interface

　　1.当一个类中的方法都是抽象的时候，那么Java中提供了另一种表示方式，称为接口，用interface

关键字表示，而类与接口之间关系用关键字implements实现表示

interface Inter
{
 public static final int NUM = 3;
 public abstract void show();
 
}
interface InterA
{
 public abstract void method();
}
class Demo
{
 public void function(){}
}
class Test extends Demo implements Inter,InterA
{
 public void show(){}
 public void method(){}
 
}
interface A
{
 void methodA();
 
}
interface B// extends A
{
 void methodB();
 
}
interface C extends B,A
{
 void methodC();
}
class D implements C
{
 public void methodA(){}
 public void methodB(){}
 public void methodC(){}
 
}

class InterfaceDemo
{
 public static void main(String[] args)
 {
  Test t = new Test();
  System.out.println(t.NUM);
   System.out.println(Test.NUM);
   System.out.println(Inter.NUM);
 }
}

　2.接口的成员特点

　　　　成员变量

　　　　　　是常量，默认是public static final

　　　　成员方法

　　　　　　都是抽象的，默认是public abstract

　　3.关系

　　　　类与类的关系

　　　　　　是继承关系，类与类只能单继承，可以多重继承。

　　　　类与接口的关系

　　　　　　是实现的关系，类可以多啊、实现接口，类继承一个类的同时，可以实现多个接口。

　　　　接口和接口的关系

　　　　　　是继承关系，接口可以多继承接口。

　　4.接口的特点

　　　　对外暴露规则，是扩展功能，接口的出现降低了耦合性(类与类之间的关系)

　　5.接口和抽象类的区别

　　　　抽象类只能是单继承，接口可以多实现，接口避免了多继承的局限性

　　　　抽象类中的数据特点：
    　　　　成员变量：可以是变量，也可以是常量
    　　　　成员方法：可以是抽象方法，也可以是非抽象方法
    　　　　构造方法：有构造方法

　　　　接口的数据特点

　　　　　成员变量:是常量public static final
　　　　成员方法：都是抽象方法。都有默认修饰 public abstract
　　　　构造方法：没有构造方法

　　　　抽象类中定义的是继承体系的共性功能而接口中定义的是继承体系中的扩展的功能

　　　　抽象类被继承是is a 关系:某某是某某的一中而接口被实现是like a 关系:某某像某某一种

abstract class Student
{
 abstract void study();
 void sleep()
 {
  System.out.println("sleep");
 }
 
}
interface Drinking
{
 void drink();
}
interface Smoking
{
 void smoke();
}
class ZhangSan extends Student implements Smoking,Drinking
{
 void study(){}
 public void smoke(){}
 public void drink(){}
}
class LiSi extends Student
{
 void study(){}
}
class InterfaceTest
{
 public static void main(String[] args)
 {
  
 }
}
class Sporter
{
 void play();
}
interface Study
{
}
class WangWu extends Sporter implements Study
{
 
}

附:

　　Random类的使用

　　　　产生随机数的数

　　　　掌握的内容

　　　　　　构造函数

　　　　　　　　Random()创建一个新的随机数的生成器

　　　　　　　　Random(long seed)使用单个long种子创建一个新的随机数生成器

　　　　　　成员方法

　　　　　　　　int nextInt()返回下一个伪随机数，它是随机生成器的序列中均匀分布的 int 值。

　　　　　　　　int nextInt(int n) 返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。

Scanner类的使用

　　1.可以从键盘的输入数据

　　2.掌握的内容

　　　　构造函数

　　　　　　Scanner(inputStream source)构造一个新的Scanner，它生成的值从指定的输入流扫描

如：Scanner sc = new Scanner(System.in);

　　　　方法摘要

　　　　　　sc.nextInt()获取整型数据

　　　　　　sc.nextLine获取字符串数据