面向对象（3）

淩亂°似流年 2023-07-07 03:43 21阅读 0赞

## 面向对象（3） ##

## 变量作用域 ##

变量分为成员变量和局部变量  
成员变量在类中，方法外，整个类中都可以使用  
局部变量在方法内，只能在方法中使用  
成员变量的生命周期随着类的生命周期  
局部变量随着方法的使用而存在，当方法结束时即死亡

## 变量的初始化 ##

变量有初始化值  
成员变量的初始化有默认值  
局部变量需要初始化，才能输出

## 方法的参数传递 ##

方法的参数有两种类型，引用类型和基本类型  
基本类型传递的是本身的值  
对象类型传递的是对象的引用（或者这么理解：引用数据类型传递的是地址）  
**基本类型演示**

public class Person {
        
    
        public void change(int a){
        
            a=20;
        }
        public static void main(String[] args) {
        
            int a=10;//这里如果去掉的话，会直接报错
            Person p=new Person();
            p.change(a);
            System.out.println(a); //10
        }
    }

**对象类型**

public class Test {
        
        public void change(Person person) {
        
            person.age = 20;// 试试下面的代码
    // Person person1 = new Person();
    // person1.age = 30;
    // person = person1;
        }
        public static void main(String[] args) {
        
            Person person = new Person();
            person.age = 10;
            System.out.println(person.age);// 10
            Test t = new Test();
            t.change(person);
            System.out.println(person.age);//20
        } }
    class Person {
        
        int age; }

## 封装 ##

封装是使用private关键字修饰的，主要是为了保证数据安全性，将数据私有化  
如果想用封装的类，那么需要创建对外的接口

## 继承 ##

继承是一个子类继承一个父类  
一个子类自能继承一个父类，但是一个父类可以有多个子类  
子类继承父类会继承父类的所有方法和属性

## super关键字 ##

super用在继承关系中的子类中，可以用来在子类中调用父类的属性，这点和this关键字相反，this调用的是当前对象的属性，super调用的是上一层父类的  
父类：

public class Person {
        
        private String name;
        private int age;
        public Person(String name, int age) {
        
            //super();
            this.name = name;
            this.age = age;
        }
        public String getName() {
        
            return name;
        }
        public int getAge() {
        
            return age;
        }
    }

子类

public class Student extends Person {
        
        private String school;
        public Student(String name, int age,String school) {
        
            super(name, age);
            this.school=school;
        }
       public String getSchool(){
        
            return school;
       }
    }

测试类

public class Test {
        
        public static void main(String[] args) {
        
            Student stu=new Student("老王",18,"南京");
            System.out.println("学生信息是：");
            System.out.println("姓名："+stu.getName());
            System.out.println("年龄："+stu.getAge());
            System.out.println("学校："+stu.getSchool());
        }
    }

## 方法重写 ##

方法重写在继承中，子类重写父类的方法，方法名相同，参数列表一致，返回值类型相同，这点和重载区别的是，重载的参数列表不同  
父类

public class Father {
        
        public void say(){
        
            System.out.println("我是芭比");
        }
    }

儿子类

public class Son extends Father {
        
        public void say(){
        
            System.out.println("儿子");
        }
    }

女儿类

public class Daughter extends Father {
        
        public void say(){
        
           System.out.println("女儿");
        }
    }

测试类

public class Test {
        
        public static void main(String[] args) {
        
            Father f=new Father();
            f.say();
    
            Father f1=new Son();
            f1.say();
    
            Father f2=new Daughter();
            f2.say();
        }
    }

## 抽象类 ##

使用abstract修饰的类为抽象类，抽象类中有实例方法，也可以有抽象方法，抽象类需要被继承来实现实例方法，抽象类中也可以有构造函数，这些函数就是给子类调用的，子类也可以调用父类的变量，经过测试，在子类的无参构造方法中，定义父类的属性，测试的时候，父类引用指向子类的时候，可以输出子类无参构造定义的父类变量属性  
父类

public abstract class Father {
        
       String name;
       int age;
        public Father() {
         }
        public Father(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
        public abstract void say();
        public void see(){
        
            System.out.println("see");
        }
    }

子类

public class Son extends Father {
        
        @Override
        public void say() {
        
         System.out.println("子类");
        }
        public Son(String name, int age) {
        
            super(name, age); }
        public Son() {
        
          this.name="s";
          this.age=5;
          System.out.println(name+age);
        }

测试类

public class Test {
        
        public static void main(String[] args) {
        
            Father f = new Son();
        f.say(); //输出的是s 5 子类
        }
    }

## 里氏替换原则 ##

就是在继承中，子类继承父类的方法，重写父类的方法，这样测试的时候实现的是子类中定义的方法，测试调用的时候，还是 Father f=new Son()，如果父类是抽象的，那么子类必须要实现父类的抽象方法，测试的时候，实现的还是子类的

public class A {
        
    public int compute(int a, int b) {
        
    return a + b; }
    public int compute_(int a, int b) {
        
    return 0; } }

子类

public class B extends A {
        
    public int compute(int a, int b) {
        
    return a - b; }
    //子类扩展的功能
    public int compute_(int a, int b) {
        
    return (a + b) / 2;
    } }

测试类

public class Test {
        
    public static void main(String[] args) {
        
    A a = new B();//需要使用父类的方法，可以通过创建子类对象类代替它
    System.out.println(a.compute(20, 30)); //-10
    System.out.println(a.compute_(20, 30));  //50
    } }

接下来是抽象的父类  
父类

public abstract class A {
        
        public int compute(int a, int b) {
        
            return a + b; }
        public abstract int compute_(int a, int b);
    }

子类  
这个方法是重写的父类的抽象方法

public class B extends A {
        
    // 子类扩展的功能
    public int compute_(int a, int b) {
        
    return (a + b) / 2;
    } }

测试类

public class Test {
        
        public static void main(String[] args) {
        
            A a = new B();//需要使用父类的方法，可以通过创建子类对象类代替它
            System.out.println(a.compute(20, 30)); //50
            System.out.println(a.compute_(20, 30)); //25
        }
    }

## 多态 ##

可以理解为一个对象的多种状态  
多态有三个前提条件：**要有继承，要有方法重写，父类引用指向子类**

## 内部类 ##

内部类就是在一个类中，又创建的一个类  
内部类分为下面几种：  
普通内部类：  
定义在方法外，类中  
可以调用外部类的属性和方法，包括私有的，普通内部类不能有静态方法和静态变量  
内部类可以通过外部.内部类来创建  
内部类

public class Demo {
        
        private int age=20;
        public void say(){
        
            System.out.println("asy");
        }
        public class demo02{
        
            void tell(){
        
                System.out.println(age);
            }
        }
    }

测试类

public class Test {
        
        public static void main(String[] args) {
        
            Demo.demo02 d = new Demo().new demo02();
            d.tell();//20
        }
    }

局部内部类  
局部类是创建在方法中的，如果局部内部类要想使用外部方法中的变量，那么外部方法中的变量必须是final，最终的，【经过测试，不是最终的也可以，这就是疑问，好像不限制】

public class Demo {
        
        private String name = "jack";
        static int COUNT = 100;
        public void say() {
        
            final String addr = "南京";
            class Inner {
        
                public void tell() {
        
                    System.out.println(name);
                    System.out.println(COUNT);
                    System.out.println(addr);//必须是最终的
                } }
            Inner in = new Inner();
            in.tell();
        } }

测试类

public class Test {
        
        public static void main(String[] args) {
        
            Demo out = new Demo();
            out.say();
        }
    }

## 静态内部类 ##

静态内部类在类中，方法外，静态内部类如果想调用外部类的属性，只能调用外部类的静态属性，如果调用外部类的非静态属性，会直接报错  
静态内部类

public class Demo {
        
        private String name = "jack";
        private static int COUNT = 100;
    
        public static class Inner {
        
            public static void say() {
        
    //System.out.println(name);//只能直接访问外部静态变量和方法
                System.out.println(COUNT);
            }
            public void tell() {
        
    //System.out.println(name);//只能直接访问外部静态变量和方法
                System.out.println(COUNT);
            } } }

测试类

public class Test {
        
        public static void main(String[] args) {
        
            Demo.Inner.say();//可以直接访问内部类的静态变量和方法
            Demo.Inner oi = new Demo.Inner();//和普通内部类的区别，可以直接创建内部类对象
            oi.tell();//成员方法需要通过对象类访问
        } }

## 匿名内部类 ##

匿名内部类是在类中方法外创建的，匿名内部类没有构造方法，外部类的方法中的局部变量必须是final最终的，匿名内部类才可以调用，

public class Demo {
        
        public void say(){
        
            System.out.println("Outer is say");
        } }

public class Test {
        
        public static void main(String[] args) {
        
            final String name = "jack";
            Demo out = new Demo() {
        
                void see(){
        
                }
                @Override
                public void say() {
        
                    System.out.println("Inner is say");
                    System.out.println(name);//name必须是最终的
                }};
            out.say();//必须是重写外部类的方法，通过调用外部类的方法，调用内部类的方法
        } }

我们为什么使用外部类  
内部类可以理解为继承，可以实现外部类的属性，也可以增加自己的字段

## 说明object类和final类 ##

object类是所有类的根，每个类都是间接或者直接继承它的，  
final类：如果一个类被定义成final类，那么这个类就不能被继承