Java面向对象

面向对象编程（oop）

1.面向过程和面向对象

1.面向过程步骤清晰，包括明确的每一步，适合比较简单的问题，实施微观的操作，
2.面向对象先将问题分类，再对每一类进行思考，再对分类下的细节思考，适合处理复杂和需要多人协作的问题
3.面向对象编程的本质是以类的方式组织代码，以对象的组织（封装）数据
4.面向对象三大特性
	1.封装
	2.继承
	3.多态 

2.方法调用
1.在一个新建的Java类（Stu.java）中编写下列静态方法

public class Stu {
    public static void say(){
        System.out.println("hi");
    }
}

在另一个Java类中可以通过Stu.say调用该方法

public class 方法的调用 {
    public static void main(String[] args) {
        Stu.say();
    }
}

如果为非静态方法

public class Stu {
    public void say(){
        System.out.println("hi");
    }
}

调用需要实例化这个类new
可以以new Stu().say();
或者Stu stu = new Stu();(对象类型 对象名 = 对象值 ; )
再通过student.say();输出
2.在同一个类里方法调用另一个方法，如果同为静态或者同为非静态则可调用，否则报错
因为静态方法与类一起加载，而非静态方法在类实例化后才存在
3.Java值传递

public class 值传递 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);
        值传递.change(a);
        System.out.println(a);
    }
    public static void change(int a){
        a=10;
    }
}

结果输出两个1
通过引用改变值

public class 引用 {
    public static void main(String[] args) {
        Person person =new Person();
        System.out.println(person.name);
        引用.change(person);
        System.out.println(person.name);
    }

    public static void change(Person person) {
        person.name="asd";
    }
}
class Person{
    String name;
}

通过person.name=“asd”;改变了class Person中的值
创建与初始对象
使用new关键字创建对象

public class apply {
    public static void main(String[] args) {
    Student student = new Student();
    /*Student是抽象的类，student是被实例化的对象
     *new创建的时候会对对象进行默认的初始化
     */
    }
}
public class Student {
    String name;
    int age;
    public void study(){
        System.out.println(this.name+"在学习");//this是这个类自己的名字在这等于Student
    }
}

new与构造器

public class person {
    String name;
    public person(){
        
    }//构造器
    public person(String name){
        this.name=name;
    }//构造器的重载
}

1.使用new必须要有构造器，本质是在调用构造器
无参构造实例化的时候不一定要定义，如果有有参定义则无参必须显示定义
2.用来初始化值
3.构造器没有返回值
4.构造器和类名相同
封装
设计程序要高内聚低耦合，高内聚就是指内部数据操作细节自己完成，不允许外面干涉，低耦合就是指暴露少量方法给外部使用
private私有
属性私有后无法在main中被改变
可以通过get/set设置改变私有的值

public class 私有 {
    private String name;
    private int age; 
    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name=name;
    }
}

继承

继承的本质是对某一批类的抽象
extends是基础的关键词，子类是父类的扩展，Java只有单继承，无多继承，一个子只能继承一个父类
可以通过子类.方法（父类中）的方法来调用父类的东西
在Java中所有的类都默认继承Object

public class Student extends People{
    private String name;
    private int age;
    private int id;
    public String getName(){

        return this.name;
    }
    public void setName(String name){
        this.name=name;
    }
    public void setId(int id){
        this.id=id;
    }
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

super.name表示在父类中的name变量，私有的private的无法继承

public class Student extends People{
    private String name;
    private int age;
    private int id;
    public  Student(){
        System.out.println("0");
    }
    public String getName(){

        return this.name;
    }
    public void setName(String name){
        this.name=name;
    }
    public void setId(int id){
        this.id=id;
    }
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

在父类中有无参构造会在子类中以隐藏的形式存在，在main方法实例化子类的时候会先调用父类的无参构造再调用子类的无参构造
调用父类或者自己的构造器必须在子类构造器第一行所以super和this不能同时调用构造方法。
B b = new A();当A为B的子类时父类的引用指向了子类。
重写：需要有继承关系，子类重写父类的方法。
重写
1.方法名必须相同
2.参数列表必须相同
3.修饰符范围可以扩大不能缩小 public>Protected>Default>private
4.抛出的异常范围可以被缩小，但不能扩大
为什么要重写？父类的功能，子类不一定需要，或者不一定满足。
父类调用子类与父类都有的方法时，如果子类未重写方法，则调用父类，如重写则调用子类，如果是子类特有的方法则无法调用。

多态

1.多态是方法的多态，属性没有多态
2.父类和子类有联系
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象
不能被重写的方法
1.static 方法，属于类，它不属于实例
2.final 常量
3.private 方法

x instanceof y;
如果x y 为父子类关系则输出true不然则输出false
如果x的类型是y的子类或是同一父类的不同子类则会编译失败
Person student = new Student(); Person是Student的父类所以可以被转换成父类
如果要调用子类的方法则要强制转换Student obj =(Student) student后通过obj调用
或者是（（Student）student）.方法名（）；
子类转父类可能丢失本来的方法

static
public class 学生 {
    private static int age;
    private double score;

    public static void main(String[] args) {
        学生 s1 =new 学生();
        System.out.println(学生.age);
        System.out.println(s1.age);
        System.out.println(s1.score);
    }
}

1.static变量可以通过类名直接调用
2.非static通过类名访问
3.静态方法可以互相直接调用但是不能调用非静态的方法，非静态方法可以调用静态方法和非静态方法

public class tryto {
    {
        System.out.println("匿名代码块");
    }
    static{
        System.out.println("静态代码块");
    }
    public tryto(){
        System.out.println("构造方法");
    }
    public static void main(String[] args) {
        tryto s1 =new tryto();

    }
}

{}是一个匿名代码块可在其中写代码，static{}是一个静态代码块可在其中写代码，运行快慢是静态代码块>匿名代码块>构造方法
1.静态代码块只执行一次，后面再有新的调用也不执行
import static java.lang.Math.random;//静态导入包下方直接调用random方法

public class tryto {
    
    public static void main(String[] args) {
        System.out.println(random());

    }
}

如果一个类被final常量定义后就不能被继承
抽象类abstract
抽象类的子类必须重写父类的抽象方法 ，抽象类不能被new只能被子类重写
接口关键字interface ，接口是程序的框架，其中只进行定义，不写方法具体的实现
接口中所有定义都是抽象的 public abstract
类 implement 接口,接口1 ，类实现接口需要将接口里方法全部重写，否则报错
一个类可以实现多个接口，可以实现伪多继承
内部类
在一个类中再定义一个类就是内部类
Outer outer = new Outer;
Outer.Inter inter = outer.new Inner();
//实例化内部类的方法
内部类可以通过get函数调用外部类私有的属性or方法