Day06-面向对象

面向对象

Java的核心思想就是OOP

1.初识面向对象

以类的方式组织代码，以对象的组织（封装）数据。

2.方法回顾和加深

方法的定义：

package com.sj.oop;

import java.io.IOException;

//Demo01 类
public class Demo01 {

    //main 方法
    public static void main(String[] args) {

    }


    /*
    修饰符 返回值类型 方法名（...){
        //方法体
        return 返回值；
    }
     */
    //return 结束方法， 返回一个结果
    public String sayHello(){
        return "Hello World!";
    }

    public void hello(){
        return;
    }

    public int max(int a,int b){
        return a>b ? a:b; //三元运算符！(如果a>b，那么结果是a，否则结果是b)k
    }

    //数组下标越界： Arrayindexoutofbounds
    
    public void readFile(String file) throws IOException{

    }
}

方法的调用：

package com.sj.oop.demo01;

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

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

package com.sj.oop.demo01;

public class Demo02 {
//    静态方法 static
//    public static void main(String[] args) {
//        Student.say();
//    }

    //非静态方法
    public static void main(String[] args) {
        //实例化这个类 new
        //对象类型 对象名  = 对象值
        Student student = new Student();

        student.say();
    }

    //static和类一起加载的
    public static void a(){
        b();
    }

    //类实例化 之后才存在
    public void b(){

    }

}

package com.sj.oop.demo01;

public class Demo03 {
    public static void main(String[] args) {
        int add = Demo03.add(1, 2);
        System.out.println(add);
    }

    public static int add (int a,int b) {
        return  a+b;
    }




}

值传递：

package com.sj.oop.demo01;

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

    //返回值为空
    public static void  change(int a){
        a=10;
    }
}

引用传递：

package com.sj.oop.demo01;

//引用传递：对象，本质还是值传递

//对象，内存！

public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null

        Demo05.change(person);
        System.out.println(person.name);//邵杰

    }

    public static void  change(Person person){
        //person是一个对象：指向的 --->Person person =new Person();这是一个具体的人，可以改变属性！
        person.name="邵杰";
    }
}



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

}

3.对象的创建分析

类和对象的关系：

package com.sj.oop.demo02;

//一个项目应该只存在一个main方法
public class Application {

}

package com.sj.oop.demo02;

//学生类
public class Student {

    //属性：字段
    String name;//null
    int age;//0
//    private (在定义字段前加上，则代表是私有的，只能在当前页面使用)


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


//Person-->身高，体重，年龄，国家
//学程序好？ 对世界进行更好的建模！---宅！ 音乐，旅游！

/*
public static void main(String[] args) {

        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象！
        //student对象就是一个Student类的具体实例！

        Student xiaoming = new Student();
        Student xiaohong = new Student();

        xiaoming.name = "小明";
        xiaoming.age = 3;
        xiaohong.name = "小红";
        xiaohong.age = 4;

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

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

        xiaoming.study();

    }
 */

创建与初始化对象：

构造器详解：

构造器：
    1.和类名相同


    2.没有返回值
作用：
    1.new 本质在调用构造方法
    2.初始化对象的值
注意点：
    1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

alt + insert（win）
commmand + N （mac）

this. =
(this. 代表当前类) (=后面是传进来的值)

package com.sj.oop.demo02;

//java--> class
public class Person  {

    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器

    String name;
    int age;

    //实例化初始值
    //构造器的作用：
    //1.使用new关键字，本质是在调用构造器
    //2.用来初始化值

    public Person() {
    }


    //重载
    //有参构造:一旦定义了有参构造，无参就必须显示定义

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //自动生成构造器
    //alt + insert（win）
    //commmand + N （mac）
}




/*
package com.sj.oop.demo02;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //使用new关键词 实例化了一个对象
        Person person = new Person("shaojie",21);

        System.out.println(person.name);//shaojie
        System.out.println(person.age);//21
    }

}


    构造器：
        1.和类名相同
        2.没有返回值
    作用：
        1.new 本质在调用构造方法
        2.初始化对象的值
    注意点：
        1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

    alt + insert（win）
    commmand + N （mac）

    this. =
    (this. 代表当前类) (=后面是传进来的值)
 */

创建对象内存分析：

方法区与堆的关系：

三种情况：

1、 java7之前，方法区位于永久代(PermGen)，永久代和堆相互隔离，永久代的大小在启动JVM时可以设置一个固定值，不可变；

2、 java7中，static变量从永久代移到堆中；

3、 java8中，取消永久代，方法存放于元空间(Metaspace)，元空间仍然与堆不相连，但与堆共享物理内存，逻辑上可认为在堆中

package com.sj.oop.demo03;

public class Pet {

    public String name;
    public int age;

    //无参构造

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

}


/*
package com.sj.oop;

import com.sj.oop.demo03.Pet;

public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name = "旺财";
        dog.age = 3;
        dog.shout();

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

 */

4.简单小结：类与对象

package com.sj.oop;

public class summary {
    public static void main(String[] args) {
        /*
        1. 类和对象
            类是一个模版：抽象，对象是一个具体的实例
        2. 方法
            定义、调用！
        3. 对应的引用
            引用类型：   【除了基本类型（8）之外的】
             对象是通过引用来操作的：栈--->堆

        4.属性：字段Filed 成员变量
            默认初始化：
                数字： 0   0.0
                char:   u0000
                boolean:    false
                引用类型:   null

            修饰符   属性类型 属性名 = 属性值！
        5.对象的创建和使用
            - 必须使用new  关键字创造对象，构造器  Person shaojie = new Person();
            - 对象的属性    shaojie.name
            - 对象的方法    shaojie.sleep()

        6.类：静态的属性   属性
             动态的行为   方法


        `封装、继承、多态`
         */
    }
}

5.面向对象三大特性

1.封装：

package com.sj.oop.demo04;

//类     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;
    }

    //command + n(mac)-->Getter and Setter
    //alt + insert(win)
    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;
        }
    }
}




//package com.sj.oop.demo04;
//
///*
//封装的意义：
//    1.提高程序的安全性，保护数据
//    2.隐藏代码的实现细节
//    3.统一接口
//    4.增加系统可维护性
// */
//public class Application {
//    public static void main(String[] args) {
//        Student s1 = new Student();
//        s1.setName("邵杰");
//        System.out.println(s1.getName());
//
//        s1.setAge(999);//不合法的
//        System.out.println(s1.getAge());
//    }
//}

2.继承：

//一个儿子只能有一个爸爸，但一个爸爸可以有多个儿子！！！

package com.sj.oop.demo05;

//在Java中，所有的类，都默认直接或者间接继承Object类
//Person 人 :父类
public class Person {
    //public  公共的
    //protected 受保护的
    //default 默认的
    //private 私有的
    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;
    }
}

package com.sj.oop.demo05;

//学生 is 人 ：派生类，子类
// 子类继承了父类，就会拥有父亲的全部方法！
public class Student extends Person{
    //ctrl + H 查看各类的关系
}

package com.sj.oop.demo05;

//Teacher is 人  ：派生类，子类
public class Teacher extends Person{
}

package com.sj.oop;

import com.sj.oop.demo05.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.getMoney());
    }

}

ctrl + H 查看各类的关系

super(类):

super注意点：
    1.super调用父类的构造方法，必须在构造方法的第一个！
    2.super 必须只能出现在子类的方法或者构造方法中！
    3.super 和 this 不能同时调用构造方法！

Vs this:
    代表的对象不同：
        this： 本身调用者这个对象
        super： 代表父类对象的应用
    前提：
        this：没有继承也可以使用
        super：只能在继承条件才可以使用
    构造方法：
        this() ;本类的构造
        super():父类的构造！

package com.sj.oop.demo05;

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

    protected String name = "shaojie";

    //私有的东西无法被继承！
    public void print(){
        System.out.println("Person");
    }
}

package com.sj.oop.demo05;

//学生 is 人 ：派生类，子类
// 子类继承了父类，就会拥有父亲的全部方法！
public class Student extends Person{

    public Student() {
        //隐藏代码：调用了父类的无参构造
        super();//调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参执行了");
    }

    //ctrl + H 查看各类的关系
    private String name = "sj";

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

    public void test1(){
        print();
        this.print();
        super.print();
    }
    public void test(String name){
        System.out.println(name); //邵杰
        System.out.println(this.name); //sj
        System.out.println(super.name); //shaojie
    }
}

package com.sj.oop;

import com.sj.oop.demo05.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        //student.test("邵杰");
        //student.test1();
    }

}

方法重写：

重写：需要有继承关系，子类重写父类的方法！
    1.方法名必须相同
    2.参数列表必须相同
    3.修饰符：范围可以扩大： public > Protected > Default >private ，
    4.抛出的异常：范围，可以被缩小，但不能扩大; ClassNotFoundException --> Exception(大)

重写，子类的方法和父类必须要一致； 方法体不同!

为什么需要重写：
    1.父类的功能，子类不一定需要，或者不一定满足！
    command + N ->override; 重写（mac） 或者 control + o
    Alt + Insert ：override; 重写（win）

package com.sj.oop.demo05;

//继承
public class A extends B{

    //Override 重写
    @Override//注解：有功能的注释！
    public void test() {
        System.out.println("A=>test()");
    }
}

package com.sj.oop.demo05;

//重写都是方法的重写，和属性无关
public class B {

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

    }
}

package com.sj.oop.demo05;

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

    protected String name = "shaojie";

    //私有的东西无法被继承！
    public void print(){
        System.out.println("Person");
    }
}

3.多态：

多态注意事项：
1.  多态是方法的多态，属性没有多态
2.  父类和子类，有联系 类型转换异常！ ClassCastException!
3.  存在条件： 继承关系，方法需要重写，父类的引用指向子类对象！ father f1 = new son();
    不能被重写的方法：
    1.static 方法，属于类，它不属于实例
    2.final 常量：
    3.pricate方法：私有的，不能重写

package com.sj.oop.demo06;

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

package com.sj.oop.demo06;

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

package com.sj.oop;

import com.sj.oop.demo06.Person;
import com.sj.oop.demo06.Student;

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

        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了: 父类的引用指向子类

        //Student 能调用的方法都是自己的或者继承父类的！
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行那些方法，主要看对象左边的类型，和右边关系不大！
        s2.run();//子类重写了父类的方法，执行子类的方法
        s1.run();
        s1.eat();
    }

}

instanceof 和类型转换：

引用类型，判断一个对象是什么类型～

某个对象 instancesof 某个类 =》true or false

        此demo061接在demo06后面！！！
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();

        //System.out.println(X instanceof Y);//能不能编译通过！ 接口

        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);//编译报错！

package com.sj.oop.demo061;

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

package com.sj.oop.demo061;

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

}

package com.sj.oop.demo061;

public class Teacher extends Person{
}

package com.sj.oop.demo061;

public class Application {
    public static void main(String[] args) {
        //类型之间的转化：基本类型转换 64 32 16 8 高转低（强制）低转高（不强制）
        //父  子

        //子类转换为父类，可能丢失自己本来的一些方法！
        Student student = new Student();
        student.go();
        Person person = student;



        /*//高             //低
        Person obj = new Student();
        student将这个对象转换为Student类型，我们就可以使用Student类型的方法了！
        Student student = (Student) obj;  //== ((Student) obj).go();*/


    }
}

/*
1.父类引用指向子类的对象
2.把子类转换为父类，向上转型；
3.把父类转换为子类，向下转型；强制转换
4.方便方法的调用，减少重复的代码！简介

抽象：     封装、 继承、 多态！  抽象类，接口

 */

static关键字详解：

如果某个类被final定义了，那这个类就不能被继承。

package com.sj.oop.demo07;

public class Person {
    /*
    {
        //代码块（匿名代码块）
    }
    static {
        //静态代码块（匿名代码块）
    }
    */

    //2
    {
        System.out.println("匿名代码块");
    }
    //1: 只执行一次～
    static {
        System.out.println("静态代码块");
    }
    //3
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("===================");
        Person person2 = new Person();
    }
}

package com.sj.oop.demo07;

//static
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);
        new Student().run();
        go();
    }

}

package com.sj.oop.demo07;

//静态导入包～
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);
    }
}

//如果类被final定义了，那这个类就不能被继承。

6.抽象类和接口

抽象类：

package com.sj.oop.demo08;

//abstract 抽象类：类（本质）extends: 单继承～       （接口可以多继承）
public abstract class Action {

    //约束～有人帮我们实现
    //abstract ，抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();

    /*特点:
        1.不能new这个抽象类，只能靠子类去实现它；约束！
        2.抽象类中可以写普通的方法～
        3.抽象方法必须在抽象类中～
        //抽象的抽象：约束～
     */

    //思考题？   抽象类不能new对象,  那存在构造器吗？
            //抽象类存在的意义～        抽象出来～    提高开发效率
}

package com.sj.oop.demo08;

//抽象类的所有方法，继承了它的子类，都必须要实现它的方法～ 除非～
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

接口：

声明类的关键字是class，声明接口的关键字是interface

接口的作用：
    1.约束
    2.定义一些方法，让不同的人实现～   10 ---> 1
    3.接口默认的方法：public abstarct
    4.常量：public static final
    5.接口不能被实例化～，why？-->接口中没有构造方法～
    6.implements可以实现多个接口
    7.实现接口必须要重写接口中的方法～
    8.总结博客～

package com.sj.oop.demo09;

//抽象的思维～ Java 架构师

//声明接口的关键字是interface ,接口都需要实现类
public interface UserService {

    //常量～   public static final
    int AGE = 99;
    //接口中的所有定义其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);



}

package com.sj.oop.demo09;

public interface TimeService {
    void timer();
}

package com.sj.oop.demo09;

//抽象类:  extends~
//类可以实现接口 implements    接口
//实现了接口的类，就需要重写接口中的方法～

//多继承～利用接口实现多继承～
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) {

    }

    @Override
    public void timer() {

    }
}

7.内部类及OOP实战

内部类：

package com.sj.oop.demo10;

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 void method(){
        class Inner{
            public void in(){

            }

        }
    }
}

//一个Java类中可以有多个class类，但是只能有一个 public class
class A{
    public static void main(String[] args) {

    }
}

package com.sj.oop.demo10;

public class Application {
    public static void main(String[] args) {
        //外部类  通过 new 关键字
        Outer outer = new Outer();

        //通过这个外部类来实例化内部类～
        Outer.Inner inner = outer.new Inner();
        inner.getID();

    }
}

package com.sj.oop.demo10;

//思想～


public class Test {
    public static void main(String[] args) {
        //没有名字初始化类,不用将实例保存到变量中～
        new Apple().eat();

        UserService userService = new UserService(){

            @Override
            public void hello() {

            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}
interface UserService{
    void hello();
}

posted @ 2021-12-04 10:48 Asuka0904 阅读(27) 评论(0) 收藏举报

刷新页面返回顶部

Asuka0904