面向对象2

第七天

封装

  1. 该露的露，该藏的藏
    程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用
  2. 封装（数据的隐藏）
    通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐
  3. 记住这句话就够了：属性私有，get/set
public class test01 {
    //privat 类 私有类
    private String name;
    private  int age;
    private  char sex;

    //get 获取 set 设置
    //在引用中中创造一个public类
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    //alt insScrlk 自动生成方法
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age<120 && age>0){
            this.age = age;
        }else{
            this.age = 3;//可以用封装进行数据判断,筛出无用条件
        }

    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
    
    
    public static void main(String[] args) {

        test01 t1 = new test01();
        t1.setName("小言");

        System.out.println(t1.getName());

        t1.setAge(255);
        System.out.println(t1.getAge());

        t1.setAge(18);
        System.out.println(t1.getAge());

    }

}

继承

  1. 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
  2. extends的意思是“扩展”。子类是父类的扩展
  3. JAVA中类只有单继承，没有多继承
  4. 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
  5. 继承关系的俩个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字 extends来表示。
    子类和父类之间，从意义上讲应该具有"is a"的关系
  6. object类super
//学生也属于人
public class Student extends Person{
    //用extends继承,派生类,子类
    Person person;//组合方法,把Person的方法拿过来用
    //public 公共的
    //protected 受保护的
    //private 私有的没法继承父类的
    //default 默认的
    //Ctrl +　Ｈ　打开继承树
     public static void main(String[] args) {
        Person person = new Person();
        //即使是空类也有默认方法
        //java所有类都直接或间接继承object
    }
}

super

super注意点：

  1. super调用父类的构造方法，必须在构造方法的第一行

  2. super必须只能出现在子类的方法或者构造方法中！

  3. super和this不能同时调用构造方法

    Vs this
    代表的对象不同：
    this:本身调用者这个对象
    super:代表父类对象的应用
    前提
    this:没哟继承也可以使用
    super:只能在继承条件才可以使用
    构造方法
    this（）;本类的构造
    super（）:父类的构造

public class Student extends Person{
    //相当于有个隐藏的super条件,切该条件不能至下
    //调用父类代码必须在第一行
    public Student(){
        System.out.println("Student无参执行");
    }

    private String name = "kirret";

    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);//上一级的name
    }


}

public class Person {

    protected String name = "小言";

    public Person(){
        System.out.println("Person无参执行");
    }
}

public class total {
    public static void main(String[] args) {
        Student student = new Student();
        student.test("you are sb");
        Student student1 = new Student();

    }
}

多态

  1. 多态是方法的多态，属性没有多态
  2. 父类和子类，有联系
  3. ClassCastException 类型转换异常

存在条件：继承条件，方法需要重写，引用名，父类引用指向子类对象

  1. static 方法 属于类 不属于实例
  2. final 是常量
  3. private 方法 私有方法无法重写

重写

  1. 需要有继承关系，子类重写父类的方法！
  2. 父类的功能子类不一定需要，或者不一定满足方法名必须相同
  3. 参数列表列表必须相同
  4. 修饰符：范围可以扩大但不能缩小： public> Protected> Default> private
  5. 抛出的异常：范围，可以被缩小，但不能扩大：C1 assnot Foundexception--> Exception（大）
  6. 子类的方法和父类必须一致，方法体不同
public class total {
    public static void main(String[] args) {
        Student student = new Student();
        student.Test();

        Person person = new Student();//静态下子类重写了父类的方法
        person.Test();//父类的引用指向子类

    }
}

public  class Person {
    public static void Test(){
        System.out.println("这是父类");
    }
}

public  class Student extends Person{
    public static void Test(){
        System.out.println("这是子类");
    }
}

instanceof

public class total {
    public static void main(String[] args) {
        Student student = new Student();
        //System.out.println(x instanceof y);x和y是否有父子关系
        System.out.println(student instanceof Student);
        System.out.println(student instanceof Person);
        System.out.println(student instanceof Object);
    }
}

public class total {
    public static void main(String[] args) {

      Person  student = new Student();
      student.Test02();//可以直接引用

        ((Student)student).Test01();
        //强制转换高转低


    }
}

static 修饰符

public  class Student {
    private static int age;//静态变量
    private double score;//非静态变量
 
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(Student.age);//类变量
        //System.out.println(Student.score);非静态没法类调用
        System.out.println(student.age);
        System.out.println(student.score);
    }
}

public  class Student {
    private static int age;//静态变量
    private double score;//非静态变量
    public void run(){

    }
    public static void go(){

    }
    public static void main(String[] args) {
       //非静态可以直接调用静态方法,静态方法不管你用不用都存在
        //非静态方法只有你调用的时候才存在
        go();//可以直接调用方法
    }
}
 

public  class Student {
    {
        //代码块 (匿名代码块),每次运行方法都要执行
        System.out.println("匿名代码块");
    }

    static {
        //静态代码块,最快,只执行一次
        System.out.println("静态代码块");
    }
    public void lock(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Student student = new Student();
        student.lock();
    }
}


import java.lang.Math;//导入包
import static java.lang.Math.random;//静态导入包

public  class Student {

    public static void main(String[] args) {
        System.out.println(Math.random());//可以直接导入包
    }
}

抽象类

//abstract 抽象类:类
//extend类是单继承 接口是可以多继承的
public abstract class Student {

    //约束等人帮我们实现
    //abstract 抽象方法,只有方法名,没有方法的实现
    public abstract void doSomeThing();
}
//特点:不能new出来,只能子类去实现它:约束
//抽象类里可以有普通方法,抽象方法必须是抽象类

接口

接口：只有规范，自己无法写方法，约束和实现分离

接口的本质是契约

  1. 约束
  2. 定义一些方法，让不同的人实现~10
  3. public abstract
  4. public static final
  5. 接口不能被实例化，接门中没有构造方法
  6. implements可以实现多个接口
  7. 必须要重写接口中的方法
//抽象类 extends局限性只能单继承 接口可以继承多个
//实现接口用Impl结尾 用implments 实现
//实现了接口的类就需要重写接口中的方法
public class UserServiceImpl implements UserService,TimeService {

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void time(double num) {

    }
}

//interface 定义关键词  接口都需要实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的 public abstract

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public interface TimeService {
    void time(double num);
    
    public static final int age=99;
    // 定义常量接口中定义的属性都是常量,一般不这么用
}

内部类

public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("这是外部类");
    }
    class Inner{
        public void in(){
            System.out.println("这是内部类");
        }
        //内部类可以获得外部类的私有属性,方法
        public void getID(){
            System.out.println(id);
        } //public static void getID(){
            //System.out.println(id);} 静态内部类
    }
    public void method(){
        class Inner{
            public void in(){
                System.out.println("这是局部内部类");
            }
        }
    }


    public static void main(String[] args) {
        Outer outer = new Outer();
        //new一个类
        Inner inner = outer.new Inner();
        //通过new的类引用内部类
        inner.in();
    }
}
//一个java文件只能有一个public 可以有多个class可以直接跑main方法测试
class A {

        }




public class Test {
    public static void main(String[] args) {
        //没有名字的初始化,不用将实例保存倒变量中
        //匿名内部类
        new Apple().eat();

        //可以直接new一个接口
        
    }
}
class Apple{
    public void eat(){
        System.out.println("eat");
    }
}
interface UserService{//接口
    void hello();
}

我好像学的太快了，囫囵吞枣什么都没学精，等有空了再回顾一下用途别的教学资料换一个教学风格走一遍

posted @ 2021-02-18 22:50  kirret  阅读(41)  评论(0)    收藏  举报