Java OPP基础

//值传递
public class Demo01 {
    public static void main(String[] args) {
        int a = 10;

        System.out.println(a);

        change(a);

        System.out.println(a); //结果输出仍为1，可以看出Java是值传递
    }

    public static void change(int a){
        a = 1;
    }
}

//引用传递：对象，本质还是值传递
public class Demo02 {
    public static void main(String[] args) {
        Person guy = new Person();

        System.out.println(guy.name);

        change(guy);

        System.out.println(guy.name);

    }

    public static void change(Person person){
        person.name = "Guy";
    }
}

//定义了一个Person类，有一个属性：name
class Person{
    String name;
}

//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        /*
        类：抽象的，实例化
        类实例化后会返回一个自己的对象！
        Red对象就是一个Trainer类的具体实例！
         */

        Trainer Red = new Trainer();
        Trainer Green = new Trainer();

        Red.name = "Red";

        System.out.println(Red.name);
        Red.study();

        Green.name = "Green";
        Green.age = 24;

        System.out.println(Green.name);
        System.out.println(Green.age);
    }
}


//训练家类
public class Trainer {
    //属性
    String name;
    int age;

    //方法
    public void study(){
        System.out.println(this.name + " is studying...");
    }
}

public class Application {
    public static void main(String[] args) {
        //new 实例化一个对象
        Person person = new Person("James");

        System.out.println(person.name);
    }
}

/*
构造器：
    1.和类名相同
    2.没有返回值
作用：
    1.new 本质在调用构造方法
    2.初始化对象的值
注意点：
    1.定义有参构造后，如果想使用无参构造，需要显示地定义一个无参的构造
 */
public class Person {
    //一个类即使什么都不写，它也会存在一个方法（构造器）

    String name;
    int age;

    //实例化初始值
    //1.使用new关键字，本质是在调用构造器
    public Person(){

    }

    //有参构造:一旦定义了有参构造，默认无参会失效，除非自己定义无参，否则无法用无参
    public Person(String name){
        this.name = name;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Applicaton {
    public static void main(String[] args) {
        Pet Dog = new Pet();

        Dog.name = "旺财";
        Dog.age = 3;

        System.out.println(Dog.name);
        System.out.println(Dog.age);

        Pet Cat = new Pet();

    }
}

public class Pet {
    public String name;
    public int age;

    public void shout(){
        System.out.println("叫了一声");
    }
}

/*
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护性增加了
 */
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("daxiong");

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

        s1.setAge(-1); //不合法的

        System.out.println(s1.getAge());
    }
}

//类     private：私有
public class Student {
    //属性私有
    private String name;
    private int id;
    private char sex;
    private int age;


    //提供一些可以操作这个属性的方法
    //提供一些public的get、set方法
    //get 获得这个数据
    public String getName() {
        return this.name;
    }

    //set 给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 > 120 || age < 0) {
            this.age = 3;
        } else {
            this.age = age;
        }
    }
}

public class Application {
    public static void main(String[] args) {
        Student student = new Student();

        student.say();

        System.out.println(student.getMoney());

        student.test("xiongmao");
    }
}

//在Java中，所有的类都直接或间接继承Object
//Person 父类
public class Person {
    public Person(){
        System.out.println("Person无参执行了");
    }

    protected String name = "熊猫";

    private int money = 10_0000_0000;

    public void say(){
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

//Student 派生类/子类
public class Student extends Person {
    //隐藏代码：调用了父类的无参构造
    //super();
    public Student(){
        System.out.println("Student无参执行了");
    }

    private String name = "Panda";

    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

//Teacher 派生类/子类
public class Teacher extends Person{
}

public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();

        B b = new A();
        b.test();

    }
}

/*
因为静态方法是类的方法，而非静态是对象的方法
有static时，b调用了B类的方法，应为b是B类定义的
没有static是，b调用的是对象的方法，而b是A类new的
即b是Anew出来的对象，因此调用类A的方法
 */
 
public class A extends B{
    public void test(){
        System.out.println("A=>test()");
    }
}

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

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定类：父类的引用指向子类
        //Student 能调用的方法都是自己的或者继承父类的！
        Student student = new Student();
        //Person 父类，可以指向子类，但是不能调用子类独有的方法
        Person person = new Student();

        student.say();
        person.say();
        ((Student)person).study();

        /*
        1.父类引用指向子类的对象
        2.把子类转换为父类，向上转型
        3.把父类转换为子类，向下转型 强制转换！
        4.封装      继承      多态
         */
    }
}

public class Person {
    public void say(){
        System.out.println("I am a person");
    }
}

public class Student extends Person{
    public void say(){
        System.out.println("I am a student");
    }

    public void study(){
        System.out.println("I am studying...");
    }
}

public class Application {
    public static void main(String[] args) {
        Object object = new Student();

        System.out.println(object instanceof Student);  //true
        System.out.println(object instanceof Person);   //true
        System.out.println(object instanceof Object);   //true
        System.out.println(object instanceof Teacher);  //false
        System.out.println(object instanceof String);   //false

        System.out.println("=============================");

        Person person = new Student();

        System.out.println(person instanceof Student);  //true
        System.out.println(person instanceof Person);   //true
        System.out.println(person instanceof Object);   //true
        System.out.println(person instanceof Teacher);  //false
        //System.out.println(person instanceof String);  编译报错

        System.out.println("=============================");

        Student student = new Student();

        System.out.println(student instanceof Student); //true
        System.out.println(student instanceof Person);  //true
        System.out.println(student instanceof Object);  //true
        //System.out.println(student instanceof Teacher);  编译报错
        //System.out.println(student instanceof String);  编译报错
    }
}

public class Person {
    public void run(){
        System.out.println("I run!");
    }
}

public class Teacher extends Person{
}

public class Student extends Person{
}

import static java.lang.Math.random;
import static java.lang.Math.PI;

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

public class Person {
    //2nd
    {
        System.out.println("匿名代码块");
    }

    //1st   只执行一次
    static {
        System.out.println("静态代码块");
    }

    //3rd
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {

        Person person = new Person();
        Person person1 = new Person();
    }
}

public class Student {
    private static int age; //静态的变量 多线程！
    private double score;   //非静态变量

    public void run(){

    }

    public static void go(){

    }

    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(Student.age);
        //System.out.println(S1.age);
        System.out.println(s1.score);
        System.out.println(Student.age);

        go();
        //run();
        s1.run();
    }
}

//abstract 抽象类
public abstract class Action {

    //abstract 抽象方法 只有方法名字，没有方法体！
    public abstract void doSomething();

    public void say(){

    }
}

/*
1.不能new这个抽象类，只能靠子类去实现它
2.抽象类中可以写普通的方法
3.抽象方法必须在抽象类中
 */

//类 extends 单继承     （接口可以多继承）
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

//interface 定义的关键字，接口都需要有实现类
public interface UserService {

    //常量    public static final
    int AGE = 99;

    //接口中的所有定义其实都是抽象的   默认  public abstract
    void run(String name);
    void delete(String name);
    void update(String name);
    void query(String name);


}


public interface TimeService {
    void timer();
}

//类 可以实现接口  implements：接口
//实现了接口的类，就需要重写接口中的方法
//多继承   利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void timer() {

    }

    @Override
    public void run(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();

        inner.in();
        inner.getID();
    }
}

public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("这是外部类方法");
    }

    public class Inner{
        public void in(){
            System.out.println("这是内部类方法");
        }

        public void getID(){
            System.out.println(id);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;

        try {   //try监控区域
            System.out.println(a/b);
        }catch (ArithmeticException e){ //catch捕获异常
            System.out.println("程序出现异常，变量b不能为0");
        }finally {  //处理善后工作
            System.out.println("finally");
        }

        //finally 可以不要fanally   IO流 资源 关闭
    }
}

public class Test2 {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;

        //假设要捕获多个异常：从小到大
        //快捷键：command+option+T
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            e.printStackTrace();    //打印错误栈信息
        } finally {
        }
    }
}