JAVA学习 Day07：JAVA面向对象

最新推荐文章于 2024-11-10 08:43:33 发布

LIVE_SEVEN

最新推荐文章于 2024-11-10 08:43:33 发布

阅读量208

点赞数

文章标签： java

本文链接：https://blog.csdn.net/LIVE_SEVEN/article/details/120702449

版权

一、什么是面向对象OOP

属性+方法就构成了一个类

对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统，但是具体到微观操作，仍然需要面向过程的思路去处理
以类的方式组织代码，以对象的组织（封装）数据
封装、继承、多态

二、方法的加深和回顾

1.方法的定义

修饰符
返回类型
break：跳出switch，结束循环 return结束方法，返回一个结果
方法名：注意规范，见名知意
参数列表：（参数类型，参数名）…
异常抛出

package com.oop;

import java.io.IOException;
import java.util.function.IntBinaryOperator;

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

    }
    /*
      修饰符  返回值类型  方法名（...）{
        方法体
        return 返回值；

      }
     */
    //return 结束方法，返回一个结果
    public String sayHello(){
        return "hello,word";
    }

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


    public  void  readFile(String file) throws IOException{//抛出异常

    }
}

2.方法的调用

1.静态方法

package com.oop.demo01;

public class Demo02 {
    public static void main(String[] args) {
        Student.say();
    }

}
package com.oop.demo01;

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

    }
}

2.非静态方法

package com.oop.demo01;

public class Demo02 {
    public static void main(String[] args) {
        //实例化这个类 new
        // 对象类型 对象名 = 对象值
        Student student = new Student();
        student.say();
    }

}
package com.oop.demo01;

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

    }
}

3.形式参数和实际参数

package com.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;
    }
}

4.值传递和引用传递

package com.oop.demo01;

import org.ietf.jgss.Oid;

//引用传递：传递一个对象，本质还是值传递
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.name ="名字";
    }
}

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

5.this关键字

三、对象的创建分析

1.类与对象的关系
类是一种抽象的数据类型，他是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
对象是抽象概念的具体实例

类是对象的模板
使用new创建对象

package com.oop.demo02;

// 学生类
public class Student {
    //属性：字段
    String name;
    int age;

    //方法

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

}
package com.oop.demo02;

// 一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        //类是抽象的，需要实例化
        //类实例化后会返回一个自己的对象
        //student 对象就是一个Student类的具体实例
        Student xiaoming = new Student();
        Student xh = new Student();

        xiaoming.name = "小明";
        xh.name = "小红";
        xiaoming.age = 3;
        xh.age = 3;

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

2.构造器

必须和类的名字相同
必须没有返回类型，也不能写void
new本质在调用构造方法
初始化对象的值
注意：定义了有参构造后，如果想使用无参构造，显示的定义一个无参的构造
alt +insert
this. 代表当前类

package com.oop.demo02;

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

    String name;

//    实例化初始值
//    1.使用new关键字，必须要有构造器，本质是在调用构造器
//    2.构造器一般用来初始化值
//    public Person(){
//        this.name = "名字";
//
//    }
//
//    //有参构造:一旦定义了有参构造，无参就必须显示定义
//    public Person(String name){
//        this.name = name;
//
//    }
    // alt + insert  自动生成构造器


    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }
}
/*
    public static void main(String[] args) {

        Person person = new Person();
        System.out.println(person.name);

    }
 */

3.创建对象内存分析

package com.oop.demo03;

public class Pet {
    public  String name;
    public  int age;
    public  void shout(){
        System.out.println("叫了一声");
    }
}
/*
    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);
    }
 */

package com.oop;

import com.oop.demo03.Pet;

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

    /*
    1.类与对象
        类是一个模板：抽象  对象是一个具体的实例
    2.方法：
        定义，调用！
    3.对象的引用
        引用类型：基本类型（8大基本类型）
          对象是通过引用来操作的：栈---->堆
    4.属性：字段 field 成员变量
        默认初始化
            数字：0 或0.0
            char：u0000
            boolean：false
            引用：null
            修饰符 属性类型 属性名 = 属性值
     5.对象的创建和使用
        - 必须使用new关键字创造对象，构造器  Person mingzi = new Person()
        - 对象的属性 mingzi.name
        - 对象的方法 mingzi.sleep()

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



     */

}

四、面向对象三大特性

1.封装

高内聚低耦合
属性私有 get/set
private 私有
atl + insert 快捷键可以快速使用get set 方法
封装具有最高程序的安全性，保护数据
隐藏代码的实现细节
统一接口，形成规范
增加了系统的可维护性

package com.oop.demo04;

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 getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120 || age<0){
            this.age = 3;
        }else {
        this.age = age;
        }
    }

}
package com.oop;

import com.oop.demo03.Pet;
import com.oop.demo04.Student;

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

    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("名字");

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

        s1.setAge(70);
        System.out.println(s1.getAge());



    }


}

2.继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extands的意思是“扩展”，子类是父类的扩展
java中类只有单继承，没有多继承
继承是类和类之间的一种关系，除此之外，类和类之间的关系还有以来，组合，聚合等
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
子类和父类之间，从意义上讲应该具有“is a”的关系
父类私有的 private 无法继承
/*
public
protected
default
private
*/
java中，所有的类都默认直接或间接继承object类
子类继承了父类，就会拥有父类的全部方法
ctrl + h 查看继承的类

3.Super

super是调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或构造方法中
super 和this不能同时调用构造方法
- this代表的对象本身调用者这个对象；super代表父类对象的引用
- this 没有继承也可以使用； super 只能在继承条件下使用
- this()只能调用本类的构造；super调用父类的构造

4.方法的重写

重写需要有继承关系，而且只能是子类重写父类的方法
方法名必须相同
参数列表必须相同
修饰符：范围可以扩大，但是不能缩小例如从private变成public
抛出的异常：异常的范围可以被缩小，但不能扩大
重写，子类的方法和父类必须要一直，方法体不同
为什么需要重写：
- 父类的功能子类不一定需要，或者不一定满足
- Alt+Insert 快捷键： override

5.多态

动态编译：类型：可扩展性
即同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件
- 有继承关系
- 子类重写父类的方法
- 父类引用指向子类对象
注意：
- 多态是方法的多态，属性没有多态性
- 父类和子类，有联系，否则会类型转换异常 ClassCastException
static 方法是静态的，属于类，不属于实例，不能重写
final 常量修饰的，无法重写
private方法私有的方法也不能重写

6.instanceof （类型转换）引用类型的转换

判断一个对象是什么类型
父类引用指向子类的对象
子类转换成父类向上转型直接转换
父类转换成子类向下转型需要强制转换，可能会丢失一些方法
方便方法的调用，减少重复的代码

7.static关键字

静态变量，静态方法，静态导入包

package com.oop.demo07;

public class Student {

    private static int age;//静态的变量
    private double score;//非静态的变量

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

        System.out.println();
    }

}

package com.oop.demo07;

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 person1 = new Person();
        System.out.println("=====================");
        Person person2 = new Person();

    }
}

final了的类就不能被继承了

package com.oop.demo07;
//静态导入包
import static java.lang.Math.PI;
import static  java.lang.Math.random;

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

五、抽象类和接口

1.抽象类
abstract 修饰符可以修饰抽象类
单继承
不能new抽象类，只能靠子类实现，它就是个约束
抽象类里可以有普通方法，抽象方法必须在抽象类中

package com.oop.demo08;

public abstract class Action {
    //约束 有人帮我们实现
    //abstract 抽象方法，只有方法名字 没有方法实现
    public abstract void dosomething();
}

package com.oop.demo08;
// 抽象类的所有方法，继承成了它的子类，都必须要实现它的方法
//除非子类也是abstract
public class A extends Action{
    public void dosomething()
    {

    }
}

2.接口
图标展示区别
在这里插入图片描述

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

可以多继承

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范！自己无法写方法，专业的约束，约束和实现分离：面向接口编程
接口就是规范，定义的是一组规则，体现了现实世界中”如果你是…则必须…“的思想
接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守
OO的精髓。是对对象的抽象，最能具体体现这一点的就是接口

package com.oop.demo09;

public interface UserService {
    //接口中的所有定义，其实都是抽象的 public abstract
    //接口都需要有实现类
    public abstract void run(String name);
    void add(String name);
    void delete1(String name);
    void update(String name);
    void query(String name);

}

package com.oop.demo09;
//抽象类：extends
//类可以实现接口 ：implements 接口
//实现了接口的类，就需要重写接口中的方法
//多继承 利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService {


    @Override
    public void run(String name) {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delete1(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

package com.oop.demo09;

public interface TimeService {
void timer();
}

接口的作用：
- 约束
- 定义一些方法，让不同的人实现
- public abstract 接口中的方法都是抽象的
- public static final 接口中定义常量
- 接口不能被实例化，接口中没有构造方法
- implements 可以实现多个接口
- 必须重写接口中的方法

六、内部类及OOP实战

1.内部类

内部类就是在一个类的内部再定义一个类
```
  -  成员内部类	
```

package com.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);

        }
    }



}
package com.oop;

import com.oop.demo10.Outer;

import javax.lang.model.element.VariableElement;

// 一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner =outer.new Inner();
        inner.getID();
    }

    }

	- 静态内部类

上面的加个 static就变成了静态内部类，但是静态内部类就加载不到id，因为类执行先加载static

	- 局部内部类

package com.oop.demo10;

public class Outer {

    //局部内部类
       public Void method(){
           
            class Inner{
                
                public void in(){
                    
                }

            }
        }

        
}

	- 匿名内部类

package com.oop.demo10;

public class Test {
public static void main(String[] args) {
//没有名字初始化类
new Apple().eat();

    UserService userService = new UserService(){
        
        public void hello(){
            
        }
    }

}

}
class Apple{
public void eat(){
System.out.println(“1”);
}
}

interface UserService{
void hello();
}

LIVE_SEVEN

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫