面向对象编程

修饰符

package OOP;

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

    }
    public void sayHello(){
        System.out.println("hello");
    }
    public int max(int a,int b){
        return a>b ? a:b; // return结束方法，返回结果  break 结束循环 continue 结束本次循环
    }
}

方法调用

非静态方法

静态方法

package OOP;

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

    }
    //static 修饰的方法和类一起加载
    public static void a(){
        b();
    }
    //类实例化之后才存在
    public  void b(){

    }
}

值传递与引用传递

值传递：

package OOP;
//值传递
public class Demo3 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a); //1
        Demo3.Change(a);
        System.out.println(a); //1
    }
    //返回值为空
    public static void Change(int a){
        a=10;
    }
}

引用传递：

package OOP;
//引用传递：对象 本质为值传递
public class Demo4 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name); //null
        Demo4.Change(person);
        System.out.println(person.name);
    }
    public static void Change(Person person){
        //person是一个对象，指向具体的类
        person.name ="xiaowei"; //xiaowei
    }
}
//定义了一个Person类，有一个属性:name
class Person{
    String name;
}

类与对象的关系

以类的方式封装代码，以对象的方式封装数据

package OOP.demo;

public class Application {
    public static void main(String[] args) {
        //类抽象的 需要实例化
        //类实例化后会返回自己的对象
        //student对象就是Student类的具体实例
        Student xiaoming = new Student();
        Student xh = new Student();
        xiaoming.name="xiaoming";
        xiaoming.age=3;
        xh.name="xh";
        xh.age=3;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
        System.out.println(xh.name);
        System.out.println(xh.age);

    }
}

package OOP.demo;

public class Application {
    public static void main(String[] args) {
        //类抽象的 需要实例化
        //类实例化后会返回自己的对象
        //student对象就是Student类的具体实例
        Student xiaoming = new Student();
        Student xh = new Student();
        xiaoming.name="xiaoming";
        xiaoming.age=3;
        xh.name="xh";
        xh.age=3;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
        System.out.println(xh.name);
        System.out.println(xh.age);

    }
}

构造器

一个类即使什么都不写，也会存在一个方法，即为默认方法

构造器一般用于初始化值

重载(上面)

使用new关键字必须要有构造器

通过new关键字调构造方法

一旦定义了有参构造，无参构造就必须显性定义(未显性定义无参的错误示例)

alt+insert 生成构造器(重载) 再选construct 直接点ok生成有参点 none生成无参

一些小结：

内存分析:

一些总结：

封装
封装主要针对属性

提高数据的安全性，保护数据

隐藏代码的实现细节

统一接口

系统可维护增加

package OOP.cage;

public class Student2 {
    private String name;  //private 私有
    private char sex;
    private int age;
    //提供一些可供操作这些属性的方法
    //提供一些 public(只有public才可被访问)的get、set方法
    //alt + insert 自动生成get set方法(选择geter and seter)


    public String getName() {//|获得数据
        return name;
    }

    public void setName(String name) {//设置数据
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {//可加条件判断年龄是否合法
        if (age > 0 && age < 120) {
            this.age = age;
        } else {
            this.age = 0;
        }
    }
}

package OOP.cage;

public class Application {
    public static void main(String[] args) {
        Student2 s1 =new Student2();
        s1.setName("xiaowei");
        s1.setAge(999); //不合法的
        System.out.println(s1.getAge());//0
        System.out.println(s1.getName());//xiaowei
    }
}

继承

java中所有的类都继承object类

父类被继承的属性为public可直接调用
子类继承了父类就会拥有父类的所有方法