Day07__面向对象

面向对象

什么是面向对象

回顾方法的定义

package objectOriented;

import java.io.IOException;

//回顾方法的定义
public class Demo01 {
    public static void main(String[] args) {

    }

    public static String sayHello(){
        return "Hello,World!";
    }

    public int max(int a,int b){
        return a>b ? a:b;
    }

    public void readFile(String file) throws IOException{
        
    }
}

回顾方法的调用

package objectOriented;

public class Student {
    //静态方法
    public static void say(){
        System.out.println("学生说话");
    }

    //非静态方法
    public void pillowTalk(){
        System.out.println("学生说悄悄话");
    }
}

package objectOriented;

//回顾方法的调用
public class Demo02 {
    public static void main(String[] args) {
        Student.say();//静态方法调用
        Student student = new Student();
        student.pillowTalk();//非静态方法调用


    }

//和类一起加载的
//    public static void a(){
//        b();
//    }
//类实列话之后才存在
//    public void b(){
//
//    }

    //区分实参和形参
    public static int add(int a,int b){
        return a+b;
    }
}

package objectOriented;

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

package objectOriented;

//引用传递
public class Demo04 {
    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 = "张三";
    }
}

class Person{
    String name;
}

类与对象的关系

package objectOriented;

public class Student {

    String name;
    int age;


    //方法
    //静态方法
    public static void say(){
        System.out.println("学生说话");
    }

    //非静态方法
    public void pillowTalk(){
        System.out.println("学生说悄悄话");
    }

    public void study(){
        System.out.println(this.name + "在学习");
    }
}

package objectOriented;

public class Demo05 {
    public static void main(String[] args) {
        //类实例化
        //类实例化后返回一个自己的对象
        Student student = new Student();
        student.study();
    }
}

构造器详解

package objectOriented;

public class Person {
    String name;

    //无参构造器
    public Person(){

    }
    //alt+insert
    //构造器（有参）
    public Person(String name){
        this.name=name;
    }
}

创建对象内存分析

简单小结类与对象

封装详解

package objectOriented2;

public class Student {

    //属性私有
    private String name;
    private int id;
    private char sex;

    //提供一些public的get，set的方法
    //alt+insert
    public String getName(){
        return this.name;
    }
    public int getId(){
        return this.id;
    }
    public char getSex(){
        return this.sex;
    }

    public void setName(String name){
        this.name = name;
    }
    public void setId(int id){
        this.id = id;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
}

什么是继承

package objectOriented2;

public class Person {

    //public
    //protected
    //default
    //private
    public void say(){
        System.out.println("人在说话");
    }
}

package objectOriented2;

//子类继承了父类，就会有父类的全部方法
public class Student extends Person{

    //属性私有
    private String name;
    private int id;
    private char sex;

    //提供一些public的get，set的方法
    //alt+insert
    public String getName(){
        return this.name;
    }
    public int getId(){
        return this.id;
    }
    public char getSex(){
        return this.sex;
    }

    public void setName(String name){
        this.name = name;
    }
    public void setId(int id){
        this.id = id;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
}

package objectOriented2;

public class Demo01 {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
    }
}

Super详解

package objectOriented2;

public class Person {

    //public
    //protected
    //default
    //private
    public String name = "Person";


}

package objectOriented2;

//子类继承了父类，就会有父类的全部方法
public class Student extends Person{

    public String name = "Student";

    public Student(){
        super();//调用父类的无参构造
    }

    public void print1(){
        System.out.println(this.name);
    }

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



}

package objectOriented2;

public class Demo01 {
    public static void main(String[] args) {
        Student student = new Student();
        student.print1();
        student.print2();
    }
}

方法重写

package objectOriented2;

public class B {
    public static void test1(){
        System.out.println("B->test()");
    }
    public void test2(){
        System.out.println("B->test()");
    }
}

package objectOriented2;

public class A extends B {
    public static void test1(){
        System.out.println("A->test()");
    }
    public void test2(){
        System.out.println("A->test()");
    }
}

package objectOriented2;

public class Demo02 {
    public static void main(String[] args) {
        //静态方法： 方法的调用只和左边定义的数据类型有关
        //非静态：重写
        A a = new A();
        B b = new A();
        a.test1();
        b.test1();
        a.test2();
        b.test2();
    }

}

多态

package objectOriented3;

public class Person {

    public void run(){
        System.out.println("run");
    }
}

package objectOriented3;

public class Student extends Person{
    public void run(){
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}

package objectOriented3;

public class Demo01 {
    public static void main(String[] args) {
        //能调用的方法都是自己的或继承父类的
        Student s1 = new Student();
        //可以指向子类，但不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        s1.run();
        s2.run();

        s1.eat();
        //s2.eat();

    }
}

instanceof和类型转换

package objectOriented3;

public class Person extends Object{


}

package objectOriented3;

public class Student extends Person{

    public void go(){
        System.out.println("go");
    }
}

package objectOriented3;

public class Teacher extends Person{
}

package objectOriented3;

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


        Object object = new Student();
        System.out.println(object instanceof Student);
        System.out.println(object instanceof Person);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof Teacher);
        System.out.println(object instanceof String);

        Person student1  = new Student();
        //System.out.println(person instanceof String);//编译报错
        ((Student)student1).go();//父类转化为子类

        Person student2  = new Student();
        Person person = student2;//子类转化为父类会丢失一些方法或属性

    }
}

static关键字详解

package objectOriented3.Demo02;

import java.sql.SQLOutput;

//如果被final修饰则不能被继承
public class Person {
    //2:赋初始值
    {
        System.out.println("匿名代码块");
    }
    //1:只执行一次
    static{
        System.out.println("静态代码块");
    }
    //3
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person = new Person();
    }
}

package objectOriented3.Demo02;

public class Student {

    private static int age;//静态变量，多线程，所有对象共享
    private double score;//非静态变量

    public void run(){

    }
    public static void go(){

    }
    public static void test(){
        //run(); 非静态方法，不能在静态方法里被调用
        go();
    }
}

package objectOriented3.Demo02;

//静态导入包
import static java.lang.Math.random;
public class Test {
    public static void main(String[] args) {
        System.out.println(random());
    }
}

抽象类

package objectOriented3.Demo03;

//abstrac 抽象类
//抽象类的所有方法，继承了它的子类都必须实现它的方法，除非子类也是抽象类
//类只有单继承，但是接口可以多继承
public abstract class Action {
    //抽象方法，只有名字，没有方法的实现
    public abstract void doSomething();
}

package objectOriented3.Demo03;

//抽象类的所有方法，继承了它的子类都必须实现它的方法
public class A extends Action{

    @Override
    public void doSomething() {

    }
}

接口的定义和实现

package objectOriented3.Demo04;

public interface UserService {
    //接口中的所有定义方法都是抽象的公共的  public abstract
    //接口中的所有定义属性都是常量 public static final

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

package objectOriented3.Demo04;

public interface TimeService {

}

package objectOriented3.Demo04;

//利用接口可以”多继承“
public class UserServiceImpl implements UserService,TimeService{

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

内部类

package objectOriented3.Demo05;

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

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

//    class static Inner2{
//        public void in(){
//            System.out.println("这是内部类的方法");
//        }
//        public void getId(){
//            System.out.println(id);
//        }
//    }
}

package objectOriented3.Demo05;

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

}

//一个java类里可以有多个class，但是只能有一个poublic class
class A{

}