Java学习笔记2

Java特性

1. 封装

• 该露的露，该藏的藏
• 数据隐藏，通常应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
• ！！！记住属性私有，get/set;

//类  public :共有
public class Student{
    //属性私有
    private String name;
    private int id;
    private char sex;
    //属性私有的数据可以通过提供public的get/set方法来实现
    //在IDEA中可以通过按ctrl+键来直接生成get/set方法
    //get 获得这个数据
    public String getName(){
        return this.name;
    }
    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }
}
//在主函数调用  
//1.先new一个对象
Student s1 = new Student();
s1.setName("张赞赞同学");

2.继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

• extends:"扩展“， 子类是父类的扩展,父类的功能子类不一定需要，或者不一定满足

• Java中类只有单继承，没有多继承

• 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等

• 继承关系的两个类，一个为子类(派生类)，一个为父类(基类)，子类继承父类，使用关键字extends来表示

• 子类和父类之间，从意义上来讲应该具有”is a"的关系

public class Application{
    public static void main(String[] args){
        Student student = new Student();
        student.test("小熊");
    }
}
//Person 人 ：父类
public class Person{
    protected String name = "呼呼地";
}
------------------------
//学生 is 人：派生类，子类
//子类继承了父类，就会拥有父类的全部方法！
//在Java中所有的类都默认直接或间接继承Object
//私有的东西不能被继承
public class Student extends Person{
    //ctrl+h 可以查看当前类的所有父类和子类
    private String name = "张赞助";
    //调用父类的构造器张，只能在子类的第一行
    public void test(String name){
        System.out.println(name);//呼呼地
        System.out.println(this.name);//当前类定义的name 张赞助
        System.out.println(super.name);//父类中的name 
    }
}

• super 注意点：

  • super 调用父类的构造方法，必须在构造方法的第一个
  • super 只能出现在子类的方法或者构造方法中；
  • super 和 this 不能同时调用构造方法

• VS this :

​ 代表的对象不同：

​ this：本身调用者这个对象

​ super：代表父类对象的应用

​ 前提：

​ this：没用继承也可以使用

​ super：只能在继承条件小才能使用

​ 构造方法

​ this():本类的构造

​ super():父类的构造

3.重写

需要有继承关系，子类重写父类的方法

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大但不能缩小：public > protected > Default > private
4. 抛出的异常 ：范围可以被缩小，但不能扩大：ClassNotFoundException----->Exception(大)
5. 子类的方法和父类必须一致，方法体不同
6. 重写都是方法的重写，和属性无关

public class Application{
    //静态的方法和非静态的方法区别很大
    //静态方法：方法的调用只和左边
    //非静态方法：才是重写
    public static void main(String[] args){
        A a = new A();
        a.test();//A
        //父类的引用指向了子类
        B b = new A();//子类重写父类的方法
        b.test();//此时输出子类的方法
    }
}
public class B{
    public void test(){
        System.out.println("B=>test()");
    }
}
public class A extends B{
    //Override 重写
    @Override //注解：有功能的注解
    public void test(){
        System.out.println("A=>test()");
    }
}

4.多态

• 即同一种方法可以根据发送对象的不同而采用多种不同的行为方法

• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多(父类，有关系的类)

• 多态存在的条件

  • 有继承关系

  • 子类重写父类方法

  • 父类引用指向子类对象 Father f1 = new Son();

    不能重写的: static 方法，属于类，不属于实例，final 常量，private方法

• ！！！注意：多态是方法的多态，属性没有多态性

• instanceof (类型转换) 引用类型
  instanceof 是一个运算符，语法为：

  // 引用类型变量(object) instanceof 类(class)
  //功能：判断前面的对象是否属于后面的类，或者属于其子类
  //如果是，返回ture，不是则返回 false
  //注意：使用instanceof 时需要保证instanceof前面的引用类型编译时的
  //类型要么与后面的类型相同，要么与后面的类型具有父子继承关系
  
  

public class Application{
    public static void main(String[] args){
        //一个对象的实际类型是确定的
        //new Student();
        //可以指向的引用类型就不确定了：父类的引用指向子类
       // Student 能调用的方法都是自己的或者继承父类的！
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();
        
        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        ((Student)s2).eat();//父类转换为子类需要强制转换
        //子类重写了父类的方法，执行子类的方法
        s1.eat();
        //类型之间的转换：父类和子类
        //子类转换为父类，可能会丢失自己的本来的一些方法
        Student student = new Student();
        student.go();
        Person person = student;//子类转换为父类
    }
}
----------------------------------------
public class Person{
    public void run(){
        System.out.println("run");
    }
    public void go(){
        System.out.println("go");
    }
}

5.了解静态导入包

import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test{
    public static void main(String[] args){
        System.out.println(random());//输出一个随机数
        System.out.println(PI);
    }
}

6.代码块

public class Person{
    //第二执行 通常用来赋初值
    {
        System.out.println("匿名代码块")；
    }
    //最先执行且只执行一次
    static{
        System.out.println("静态代码块")；
    }
    //第三执行
    public Person(){
        System.out.println("构造方法");
    }
}

7.静态与非静态

public class Student{
    private static int age;//静态的变量 
    private double score;//非静态的变量
    public static void main(String[] args){
        Student s1 = new Student();
        System.out.println(Student.age);//静态的变量才能直接在该类调用
        System.out.println(s1.age);
        System.out.println(s1.score);
    }
}

8.抽象类

//abstract 抽象类     extends 类 都是单继承
public abstract class Action{
    //约束 有人帮我们实现方法、
    //abstract 抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething{
        //1.不能new 这个抽象类，只能靠子类去实现它：约束
        //抽象类中可以写普通的方法’
        //抽象方法必须在抽象类中
        //抽象类没有构造器
    }
}

9.多继承

//类可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法
//多继承，利用接口实现
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name){
        
    }
}
//作用：1. 约束
    // 2.定义一些方法，让不同的人去实现
    // 3.public abstract 定义方法
    // 4.public static final 定义常量的修饰符
    // 5.接口不能被实例化，接口中没有构造方法
    // 6.implements可以实现多个接口
    // 7.必须要重写接口中的方法

10.接口

//interface 定义的关键字， 接口都需要有实现类
public interface UserService{
    //常量 public static final
    int age = 99;
    //接口中的所有定义的方法其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

11.了解外部类和内部类

public class Outer{
    private int id=20;
    public void out{
        System.out.println("这是外部类的方法");
    }
    public void Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
    }
    //获得外部类的私有属性
    public void getID(){
        System.out.println(id);
    }
}
------------------------------------
public class Application{
    public static void main(){
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();
    }
}