Java面向对象- -day4

接口的定义

接口可以看成是特殊的抽象类。

接口使用interface关键字创建。

接口中只能定义常量和抽象方法

接口中接口的实现—implements关键字

一个类可以实现多个接口，多个接口之间用逗号分隔。这个类需要实现所有接口的抽象方法。
接口可以作为一种类型声明变量，一个接口类的变量可以引用实现了该类的对象。通过该引用，调
用接口中的方法

// 定义接口： 常量， 抽象方法。
public interface Fly {
  public static  final  int  LIFE= 100; // 生命值
  public abstract  void fly(); // public abstract -- 接口中的方法，默认就是公
开，抽象的，所有省略这两个关键字。
  void fly(String good);// 借助于什么力量飞行
}
interface Run{
  public static  final  int  LIFE= 100; // 生命值
  void  run();
}
// 定义一个人类实现接口(Run)
abstract class Person implements Run{
}
1.3接口的继承
接口间可以存在继承关系，一个接口可以通过extends关键字继承另外一个接口。
子接口继承了父接口中定义的所有方法。
class Doctor extends  Person{
  @Override
  public void run() {
 }
}
// 定义一个鸟类实现接口(Fly ， Run)
class  Bird implements Fly , Run{
  @Override
  public void fly() {
    System.out.println("鸟在天上飞。。。");
 }
  @Override
  public void fly(String good) {
    System.out.println("鸟吃了：" + good +" , 可以飞......");
 }
  @Override
  public void run() {
    System.out.println("鸟有时候跑.............");
 }
}
class TestBird{
  public static void main(String[] args) {
    // 1. 创建鸟，赋值给鸟类型，调用其所有方法
    Bird b = new Bird();
    b.fly();
    b.fly("虫子");
    b.run();
    // 2. 创建鸟，赋值给Fly类型，调用其所有方法
    Fly b1 = new Bird();
    b1.fly();
    b1.fly("玉米");
    // 3. 创建鸟，赋值给Run类型，调用其所有方法
    Run b2 =new Bird();
    b2.run();
 }
}

接口的继承

接口间可以存在继承关系，一个接口可以通过extends关键字继承另外一个接口。
子接口继承了父接口中定义的所有方法。

// 接口，可以通过extends，实现继承多个接口。
interface YunDonYuan extends  Run , Fly{ // 继承之后，就有三个方法。
  void excise(); // 练习
  void test(); // 考试
}
// 练习： 定义一个People类型， 具有 : 名字， 性别， 身份证号码
class  People{
1.4函数式接口
2.内部类的定义
一个类可以定义在另外一个类的内部，定义在内部的类称为内部类,其所在的类称之为外部类。
定义在内部的类，一般只服务于其外部类，对外部类具备可见性，内部类可以直接使用外部类的成
员及方法。
  String name;
  String sex;
  String id;
}
class TestPinPang{
  public static void main(String[] args) {
    People  p1= new PinPang();
    YunDonYuan p2 =new PinPang();
    Fly p3 = new PinPang();
    Run p4 = new PinPang();
    PinPang p5 = new PinPang();
 }
}
// 练习： 定义一个游泳运动员： 队员编号 ，身高， 体重 ， 继承Pople , 实现YunDonYuan接
口 ，定义一个根据不同的泳姿游泳的方法。
//    然后创建游泳运动员对象，分别赋值给自己和父类的引用。
// 练习： 定义一个乒乓球运动员，具有：队员编号 ，身高， 体重 ， 继承Pople , 实现
YunDonYuan接口 ， 再定义方法： 比赛。
class PinPang extends  People implements  YunDonYuan{
  String code; // 队员编号
  double high; // 身高
  double weight; // 体重
  public  void biSai(){
 }
  // 需要实现父类中的素有抽象方法。
}

函数式接口

// 注解：可以放在方法的前面， 类前面， 变量的前面。
//   ** 有特殊的功能，对类， 方法， 变量进行一些作用。
@FunctionalInterface  // 函数式接口 , 使用这个注解之后， 接口内部只能有一个抽象方法。
public interface Eat {
  public abstract  void  eat();
}

内部类的定义

一个类可以定义在另外一个类的内部，定义在内部的类称为内部类,其所在的类称之为外部类。
定义在内部的类，一般只服务于其外部类，对外部类具备可见性，内部类可以直接使用外部类的成
员及方法。

通常内部类不能独立于外部类存在, 通过外部类对象，创建内部类对象，如下语法规则：

Outer outer=new Outer();
Inner inner=outer.new Inner();

public class Outer { // 外部类
  int x;
  int y;
  public  void  print(){
    System.out.println("["+x+","+y+"]");
 }
  class  Inner{ // 内部类
    public int sum(){
      print();  // 内部类， 可以直接使用外部类的成员方法
      return  x +y; // 内部类，可以直接使用外部类的成员变量。
   }
 }
}
class  TestInner{
  public static void main(String[] args) {
    // 内部类Inner对外不可见。
   // Inner i = new Inner();
    Outer outer =new Outer();
    outer.x = 10 ;
    outer.y = 10;
    Outer.Inner inner = outer.new Inner();
    int sum = inner.sum();
    System.out.println("和：" + sum);
 }
}

匿名内部类的定义

如果在一段程序中需要创建一个类的对象（通常这个类需要实现某个接口或者继承某个类），而且
对象创建后，这个类的价值也就不存在了，这个类可以不必命名，称之为匿名内部类。

import java.util.Timer;
import java.util.TimerTask;
public class TimerDemo1 {
  public static void main(String[] args) {
    Timer t = new Timer();
    // TimerTask是一个抽象类。
    // ** 这里使用了匿名内部类。
    t.schedule(new TimerTask() {
      @Override
      public void run() {
        System.out.println("该起床了");
     }
   } , 1000 , 5000);

局部内部类

定义在方法中的类，称为局部内部类

public class Outer1 {
    public void fun(){
        //定义在方法中的类成为局部内部类
        class Inner{
            public void fun(){
                System.out.println("这是局部内部类");
            }
        }
        //局部内部类只能用在所在成员的内部方法中
        Inner inner=new Inner();
        inner.fun();
    }
}
class TestDemo{
    public static void main(String[] args) {
        Outer1 outer1=new Outer1();
        outer1.fun();
    }
}

静态内部类

使用static修饰的成员内部类称为静态内部类，在外部类加载时存在

public class Outer3 {
    //static修饰可以通过类名调用
    static class Inner{
        public void fun(String str){
            System.out.println("这是静态内部类"+str);
        }
    }
    public void fun(){
        System.out.println("这是一个普通方法");
    }

    public static void main(String[] args) {
        //完整写法
        Inner inner=new Outer3.Inner();
        inner.fun("hello");
        //静态内部类随着外部类的加载而存在，可以直接通过new创建对象
        new Inner().fun("hello  world");
        //普通方法
        Outer3 outer3=new Outer3();
        outer3.fun();
        //对象.方法名
        new Outer3().fun();

    }
}

值传递和引用传递

如果一个方法的参数为引用类型，直接修改该参数会对其造成影响。
如果一个方法的参数为引用类型，该方法中又创建了新对象，不会对实际参数造成影响。
如果一个方法的参数为字符串，该方法中赋值了一个新字符串，不会对实际参数造成影响
如果一个方法的参数为原始类型，该方法不会对实际参数造成影响。

String类型分析

从源码可以看到java.lang.String 是被final修饰的，所以，字符串对象一旦创建就不可变。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {

    @Stable
    private final byte[] value;

    
    private final byte coder;

  
    private int hash; // Default to 0

  
    private static final long serialVersionUID = -6849794470754667710L;

   
    static final boolean COMPACT_STRINGS;

1. 字符串对象具有只读特性，任何对字符串的操作实际上是对其引用的操作。
2. 字符串提供了toString(),equals()，hashCode()方法的重写

字符串常量池

常量池在JVM的堆内存区中

直接使用双引号声明出来的String对象会直接存储在常量池中。

如果不是用双引号声明的String对象，可以使用String提供的intern()方法

// *** 字符串常量池。
public class Demo1 {
  public static void main(String[] args) {
    // 字符串对象
    String str = "a"; // str是一个引用你该地址， 指向对象。
    String str1 = new String("a"); // str1是一个引用你该地址， 指向对象。
    String str2 = "a" ;// 到常量池，找是否有对象”a“ ，找到了就把引用该地址赋值给
str2. 找不到就再常量池创建这个对象。然后把地址赋值为str2.
    String str3 = new String("a"); // new ， 就创建对象。
    // 等号就是再比较对象的引用地址是否相同。
6.2引用传递分析
6.3String类型的分析
7.作业
    System.out.println(str == str1); // false
    System.out.println(str == str2); // true
    System.out.println(str == str3); // false
    System.out.println(str1 == str3); // false
 }
}