java基础学习笔记 - 面向对象课时1

本文主要是介绍java基础学习笔记 - 面向对象课时1，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

p67 封装详解

1、封装的好处：
1）程序设计要追求“高内聚 低耦合”，高内聚就是类的内部数据操作细节自己完成，不许外部干涉；低耦合即仅暴露少量的方法给外部使用
2）复杂性封装，只对外提供简单的操作入口， 隐藏代码的实现细节，看不到实物复杂的那一面，只展示事物简单的一面
3）封装之后形成真正的“对象”，真正的“独立体”，增强了系统的可维护性
4）封装之后提高了代码的安全性，保护了数据
5）封装意味着有统一接口，程序可以重复使用，适应性强

2、封装的实现：属性私有-get/set
1）类的所有属性私有化，外部程序不能直接访问，使用private关键字修饰，private修饰的数据只能在当前类中访问
2）对外提供简单的操作入口，以后外部程序想要方问对象，必须通过这些简单的入口进行访问：
　　- 对外提供两个公开的方法作为入口，get/set方法
　　- set/get方法必须是 public修饰的
　　- 调用set方法修改属性，set方法只负责修改数据，没有返回值，通过传参修改实例变量的值
　　- 调用get方法读取属性，有返回值类型，get方法负责返回该类型的数据
　　- 可以在get/set的方法体中进行安全过滤

3、get/set 的语法：

　　　　public 返回值类型 getName(){return field;}
　　　　public void setName(形参){ }

　　　　public returntype getName(){
　　　　　　return field; 　}

　　　　public void setName(type variable){
　　　　　　this.field = value;
　　　　　　... ... 　　}

  //示例3-1

public class D03{
    public static void main(String[] args){
        
        Student s = new Student();
        
        //通过方法传参设置值
        s.setName("小明",13,'男');
        
        //打印返回的数据
        System.out.println(s.getName());
        System.out.println(s.getAge());
        System.out.println(s.getSex());
        
    }
}


//Student类
public class Student{
    
    //属性私有
    private String name;
    private int age;
    private char sex;
    
    //提供一些可以操作类的属性的方法
    //提供一些 public的 get、set方法
    //给数据设置值
    public void setName(String name,int age,char sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }    
    
    //获取这个数据
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
    public char getSex(){
        return this.sex;
    }
}

 //示例3-2：构造器测试，重载，get/set测试

//构造器类
public class Constructor{
    
    public static void main(String[] args){
        
        //调用无参构造
        Account act1 = new Account();
        
        //通过入口访问对象的属性
        System.out.println("账号：" + act1.getActno());
        System.out.println("余额：" + act1.getBalance());
        
        //调用有参构造
        Account act2 = new Account("110",10000);
        
        //访问对象的属性
        System.out.println("账号：" + act2.getActno());
        System.out.println("余额：" + act2.getBalance());
        
        //通过入口修改对象的属性
        act2.setActno("act-110");
        act2.setBalance(200000);
        System.out.println("账号：" + act2.getActno());
        System.out.println("余额：" + act2.getBalance());
    }
}


//定义账户类
public class Account{
    
    private String actno;
    private double actbalance;
    
    //构造方法重载
    //构造方法初始化实例变量手动或默认
    public Account(){
        //actno = null;
        //actbalance = 0.0;
    }
    
    public Account(String s){
        actno = s;
        //actbalance = 0.0;
    }
    
    public Account(double d){
        //actno = null;
        actbalance = d;
    }
    
    public Account(String s, double d){
        actno = s;
        actbalance = d;
    }
    
    //访问入口get/set
    public String getActno(){
        return actno;
    }
    public void setActno(String actno){
        this.actno = actno;
    }
    
    public double getBalance(){
        return actbalance;
    }
    public void setBalance(double balance){
        this.actbalance = balance;
    }
}

p68 继承 extends关键字
　　- 继承是类和类之间的一种关系，此外类和类之间的关系还有依赖、组合、聚合等
　　- 继承的本质是对一批类的抽象，从而实现对现实世界更好的建模
　　- 继承关系的两个类，子类是派生类，父类的基类
　　- 子类继承父类，子类是父类的扩展，子类拥有父类的全部的属性和方法
　　- java中类只有单继承没有多继承，一个子类只能继承一个父类，一个父类可以扩展多个子类
　　- java中所有的类都默认继承 Object类

　　　　public class 子类名 extends 父类名{ }

2、有 final 修饰的类将不能被继承
如：pubic final class person{} //该类将不能被继承

 示例4:

public class D04{
    public static void main(String[] args){
        
        Student student = new Student();
        
        student.say();            //说了一句话
        System.out.println(student.money);    //10_0000_0000
    }
}


//Person类
public class Person{
    
    public int money = 10_0000_0000;
    
    public void say(){
        System.out.println("说了一句话");
    }
}


//Student类
public class Student extends Person{}

 p70 重写override

1、重写与父类引用的逻辑
　　- 在继承关系中，子类可以重写父类的方法，属性不存在重写
　　- 重写的方法通常是非静态的、public的
　　- 父类型的引用可以指向子类对象，但子类的引用不能指向父类对象
　　- 父类型的引用指向子类对象，相当于创建了一个新的隐藏的子类型的对象，但它没有该子类的元素，而是只继承父类的所有属性和方法，被重写的方法在这里被覆盖，因此通过父类引用调用重写的方法，相当于调用了子类的方法，父类引用也无法真正访问子类对象
　　- 如果重写的方法是静态的，父类的引用仍然调用父类的方法，静态的方法无法被重写

2、重写的语法
　　- 重写的方法名、参数列表都必须相同
　　- 重写的方法体不同，执行的功能不同
　　- 修饰符：范围可以扩大但不能缩小 public>protected>default>private
　　- 抛出的异常：范围可以被缩小但不能扩大 ClassNotFoundException < Exception
3、为什么需要重写
　　- 父类的功能，子类不一定需要或者不一定满足

4、以下情况不能重写：
　　- static 修饰的方法
　　- private 修饰的方法
　　- final 定义的常量

 //示例7-1：重写静态方法的调用

public class T07{
    public static void main(String[] args){
        
        A a = new A();
        B b = new A();
        
        a.test();  //相当于A.test();
        b.test();  //相当于B.test();
    }
}


//子类重写父类的方法
public class A extends B{
    public static void test(){
        System.out.println("A=>test()");
    }
}


//父类
public class B{
    public static void test(){
        System.out.println("B=>test()");
    }
}

 //示例7-2：重写非静态方法的调用

public class T07{
    public static void main(String[] args){
        
        A a = new A();
        B b = new A();
        //非静态方法的重写，通过引用调用的方法是对象的方法
        a.test();  //A=>test()
        b.test();  //A=>test()
    }
}


//子类重写
public class A extends B{
    public void test(){
        System.out.println("A=>test()");
    }
}


//父类
public class B{
    public void test(){
        System.out.println("B=>test()");
    }
}

 //示例7-3：重写的辩证 父类引用指向子类对象的情况

public class T07{
    public static void main(String[] args){
        //非静态方法的重写
        A a = new A();
        B b = new A();    //相当于隐藏创建了一个父类对象
        
        //重写方法时，父类的引用默认调用子类的方法
        a.test();  //A=>test()
        b.test();  //A=>test()
        
        //显示创建父类对象，调用被重写的父类方法
        B c = new B();
        c.test();  //b=>test()
        
        //不能调用子类独有的方法
        //b.test1();
        
        //可以访问父类的属性 、方法
        System.out.println(b.name);        
        b.test2();
    }
}


//子类继承父类
public class A extends B{
    
    //重写方法
    public void test(){
        System.out.println("A=>test()");
    }
    
    //独有方法
    public void test1(){
        System.out.println("A1=>test()");
    }
}


//父类
public class B{
    
    String name;
    
    public void test(){
        System.out.println("B=>test()");
    }
    
    public void test2(){
        System.out.println("B2=>test()");
    }
}

p71 多态：
　　- 多态是方法的现象，属性没有多态性
　　- 多态存在于有继承关系的类中，父类引用指向子类对象
　　- 一个对象的实际类型是确定的，但指向它的引用的类型可以有多个父类类型
　　- 子类能调用的方法都是它自己的或者继承父类的
　　- 父类型的引用可以指向子类对象，但是不能调用子类独有的属性和方法，只能调用子类重写的方法
　　- 用强制转换类型的办法，使父类引用s2的类型降级，就可以得到一个指向子类对象的子类引用，这时该引用可以完全访问子类对象

例：Student s1 = new Student();
　　Person s2 = new Student();
　　Object s3 = new Student();
　　((Student)s2).eat();

 //示例8：

//测试类
public class T08{
    public static void main(String[] args){
        
        //指向对象的引用类型是多种的
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();
        
        s1.run();    //Student run
    
        //子类重写了父类run()方法，S2默认调用子类的方法
        s2.run();    //Student run
        
        //s2不能调用子类独有的方法
        //s2.eat();
        
        //用强制转换类型的办法，使s2类型降级，可以访问子类对象，可能会丢失什么
        ((Student)s2).eat();
    }
}


//子类
public class Student extends Person{
    
    //重写run()方法
    public void run(){
        System.out.println("Student run");
    }
    
    //子类的独有方法
    public void eat(){
        System.out.println("Student eat");
    }
}


//父类
public class Person{
    
    public void run(){
        System.out.println("Person run");
    }
}

//即使再小的帆也能远航2021-11-13

这篇关于java基础学习笔记 - 面向对象课时1的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！