Java初识面向对象

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量139 收藏
点赞数
文章标签： java 开发语言 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50582233/article/details/129827151
版权

初识面向对象(OOP)

面向过程&面向对象

（属性+方法 == 类）

面向过程思想（线性思维）

  • 步骤 清晰简单，第一步做什么，第二步做什么…

  • 面对过程适合处理一些较为简单的问题

面向对象思想
  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思考
  • 面对对象适合处理一些 复杂 的问题，适合处理 多人协作 的问题！
  • 对于描述复杂的事物，为了宏观上把握，**从整体上合理分析，我们需要用到面向对象的思路来分析整个系统。**但是，具体到微观操作，还是要用到面向过程的思路去处理

什么是面向对象

  • 面向对象编程(Object-Oriented Programming,OOP)
  • 对象是类的实例，类是对象的模板。
  • 面向对象的本质就是：以类的方式组织代码，以对象的方式组织(封装)数据（即类是一个模块，可以创建对象来进行模块内属性的赋值）
  • 抽象(将对象的共同特点剥离、抽取出来)
  • 三大特性：
    • 封装(把数据封装起来，对外开一个小口，用来调用数据)
    • 继承(父类和子类之间可以进行继承)
    • 多态(同一个事物会有不同的形态)
  • 从认识论角度考虑是先有对象后又类。对象是具体的事物 。类是抽象的，是对 对象 的抽象 比如：先有了人，才有了一部分老师
  • 从代码执行角度考虑是先有类后有对象。类是对象的模板。比如：通过印钞机来印钞

方法回顾和加深

方法的定义
  • 修饰符
  • 返回类型(返回值必须与返回类型保持一致)
package ooc;
//Demo01类
public class Demo01 {
    //main 方法
    public static void main(String[] args) {


    }
    //public :修饰符，可以被任何class调用
    //static :类变量，可以直接被调用
    //String :返回值类型 void 表示空，即没有返回值，但是也可以写 return;
    //fun :方法名
    //fun(形参)
    public static String fun(){
        //方法体
        //return 返回值；
        return "Hello,World";
    }
    public int max(int a,int b){
        return a>b?a:b;//三元运算符
    }
}

  • break:跳出switch,结束循环

  • break和return 的区别

    return 表示结束方法，返回一个结果。不再执行return 之后的代码

  • 方法名：注意规范就OK 见名知意 驼峰命名法

  • 参数列表：类型一：(参数类型 变量名) 类型二：可变参数：…

  • 异常抛出：比如： Arrayindexoutofbounds（数组越界）

								//	抛出		异常
public void readFiles(String file) throws IOException{
    
}
方法的调用

  • 静态方法和非静态方法

    静态方法(static)

//(类名).方法名
Student.say();

​ 非静态方法

//实例化这个类 new
//对象类型 对象名 =对象值
Student student=new Student();
student.say();

即在定义了一个非静态方法后，可以通过new关键字来实例化，进而实现方法的调用

​ 二者区别

package ooc;

public class Demo02 {
    public static void main(String[] args) {
       
    }
    /*
    1.同一类中静态方法之间可直接相互调用
    2.同一类中非静态方法也可直接调用静态方法  
    3.同一类中非静态方法也可直接相互调用
    4.同一类中静态方法不可直接调用非静态方法
     */

    //static静态方法是和类一起加载的
    public static void a(){
       b();
    }
    //非静态方法是在类实例化之后才存在的
    public void b(){
        a();
    }
}

  • 形参与实参

    ​ 静态方法实现两数之和

    package ooc;

public class Demo03 {
    public static void main(String[] args) {
        //形参和实参的类型必须一致
        int result=add(2,6);
        System.out.println(result);
    }
    // int a,int b就是占位符，没有实际内存
    public static int add(int a,int b){
        return a+b;
    }
}

    ​ 非静态方法实现两数之和

    package ooc;

public class Demo03 {
    public static void main(String[] args) {
        //形参和实参的类型必须一致
        Demo03 demo03=new Demo03();
        System.out.println(demo03.add(6,6));

    }
    // int a,int b就是占位符，没有实际内存
    public int add(int a,int b){
        return a+b;
    }
}

  • 值传递和引用传递(java中全部都是值传递)

    ​ 值传递

    package ooc;
//值传递
public class Demo04 {
    //值传递 只是单纯的执行了方法，方法结束后 实参仍然不会被改变
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);//1
        change(a);
        System.out.println(a);//1
    }
    //返回值为空
    public static void change(int n){
        n=10;
    }
}

    ​ 引用传递

    package ooc;
//引用传递：对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null
        //修改的是Person类中的值，而不是方法中的值
        Demo05.change(person);
        System.out.println(person.name);//对酒当歌，人生几何

    }
    public static void change(Person person){
        //person是一个对象,指向的是--->Person person=new Person(); 这是一个具体的人，可以改变属性！
        person.name="对酒当歌，人生几何";
    }
}

//一个类中只能有一个 public class 但是可以有多个 class
//定义了一个Person类，有一个属性:name
class Person{
    String name;
}

类和对象的创建

类和对象的关系
  • 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是这并不能代表某一个具体的事物。
    • 动物、植物、手机、电脑…
    • Person类、Pet类、car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
  • 对象是抽象概念的具体实例
    • 张三就是人的一个具体实例，张三家的旺财就是狗的一个具体实例
    • 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

new关键字

创建与初始化对象
  • 使用new关键字创建对象

Student类

package Demo;

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

    //方法
    public void study(){
        //this.name代表当前这个类的name
        System.out.println(this.name+"学生在学习");
    }
}

Application类

package Demo;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类：抽象的，需要实例化
        //类实例化之后会返回一个自己的对象！
        //student 对象就是Student类的具体实例！
        
        //类名      对象名=new   类名()   实例化
        Student xiaoming = new Student();
        Student xiaohong = new Student();
        //对象名.属性  可以用来赋值
        xiaoming.name="小明";
        xiaoming.age=3;
        xiaohong.name="小红";
        xiaohong.age=6;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);
    }
}
  • 使用new关键字创建的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用

构造器详解

  • 类中的构造器也称构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点
  1. 必须和类的名字相同
  2. 必须没有返回类型，也不能写void
package Demo;
//.java--->.class
public class Person {
    //一个类即使什么都不写，也会默认存在一个方法，这个方法就是构造方法
    //显式的定义构造器
    String name;
    int age;
    //构造器可以实例化初始值

    /*
    构造器的作用：
    1.使用new关键字本质是调用构造器 
    2.构造器一般用来初始化值
     */
    //无参构造
    public Person(){
        this.name="duijiudangge";
    }
    //有参构造:一旦构造了有参构造，无参就必须显示定义

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

    /*alt+shift+0:自动生成构造器
    1.Constructor-> Select None,自动生成无参构造
    2.Constructor -> 选择类中属性作为形参-->OK,自动生成类中属性对应参数构造
     */
}
/*
public static void main(String[] args) {
        //使用new 关键字实例化了一个对象
        Person person = new Person("renshengjihe");
        System.out.println(person.name);//null
    }
    构造器：
    1.与类名相同
    2.无返回值
    作用：
    1.new 本质在调用构造方法
    2.初始化对象的值
    注意点：
    定义了有参构造之后，如果想要使用无参构造，必须要显式的定义一个无参构造(即需要自己写出来，而不是用系统默认生成的)
 */
如何在IDEA中打开class文件
  1. 打开项目结构；
  2. 单击模块；
  3. 添加内容根

构造器必须掌握

方法的重载

方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法。调用时，会根据不同的参数表选择对应的方法。

两同三不同。

——同一个类，同一个方法名。

——不同：参数列表不同。（类型，个数，顺序不同）

  • 只有返回值不同不构成方法重载。

  • 只有形参的名称不同，不构成方法重载。

  • 与普通方法一样，构造函数也可以重载。

对象的创建分析

package Demo.Demo01;

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);
        Pet cat = new Pet();


    }
 */

在这里插入图片描述

这就是为什么同样是 new Pet() 能同时产生多个对象变量的原因

总结

    package Demo;
    
    public class summary {
        /*
        1.类与对象
            类是一个模板，是抽象的。对象是一个具体的实例，可以通过创建对象来调用类
        2.方法
            方法的定义与调用
            定义： 修饰符 (static) 返回值 函数名(参数)
            返回值类型 void 表示空，即没有返回值，但是也可以写 return;
            调用：Student student=new Student();
                 student.say();
        3.对应的引用
            引用类型：除基本数据类型(8)外,对象是通过引用来操作的：栈-->堆(真实对象在堆里)  比如：String
            八大基本数据类型：
            int
            byte
            short
            long
            float
            double
            char
            boolean
        4.对象的属性：一般称为字段(Field)/变量/成员变量
            默认初始化(定义属性时,即使不对其进行初始化，也会有固定的值)：
                数字:0    0.0
                char:u0000
                boolean:false
                引用类型:null
            修饰符 属性类型 属性名=属性值
        5.对象的创建和使用
            -必须要使用new关键字进行对象的创建
            要用到构造器(所谓构造器其实就是一种特殊的无返回值且与类名相同的方法) Person duijiudangge = new Person();
            -对象的属性  duijiudangge.name;
            -对象的方法  duijiudangge.shout();
        6.类(类==属性+方法)
            1>.静态的属性    属性
            2>.动态的行为    方法
    
        7.对象的三大特性：
            1>.封装(把数据存起来，开一个小口，用来调用数据)
            2>.继承(子类可以继承父类的属性)
            3>.多态(同一个事物有多种形态)
         */
    }

面向对象三大特性

封装

  • 该藏得藏，该漏的漏
    • 我们程序设计要追求**“高内聚,低耦合”**。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；(比如银行内的运作，只有内部人员知道) 低耦合：仅暴露少量的方法给外部使用(比如去银行取钱的人，只能取自己银行卡的钱，不能取别人的钱)
  • 封装(数据的隐藏)
    • 通常,应禁止访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
  • 记住这句话就够了：属性私有，get/set
package Demo.Demo02;
/*
1.提高程序的安全性,保护数据
2.隐藏代码的事项细节
3.统一接口
4.系统可维护性增加了
 */

//类     private:私有
public class Student {
    //属性私有
    private String name;//名字
    private int age;//年龄
    private char sex;//性别
    //提供一些可以操作这个属性的方法！
    //提供一些public 的get 、set方法

    //get 获得这个数据
    public String getName(){
        return this.name;
    }
    //给这个数据设置值
    public void setName(String name){
        this.name=name;
    }
    //快捷键：alt+insert(alt+shift+0)
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        //判断数据是否合法
        if(age<120 && age>0){
            this.age=age;
        }else{
            this.age=3;
        }

    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

/*
public static void main(String[] args) {
        Student s1 = new Student();
        s1.getName();
        s1.setName("对酒当歌");
        //方法的重载
        //方法名、参数列表
        System.out.println(s1.getName());
        s1.setAge(3);
        System.out.println(s1.getAge());
    }
 */

继承

  • 继承的本质是堆某一批类的抽象，从而实现对现实世界更好的建模
  • extends的意思是"扩展"。子类是父类的扩展。
  • Java中类只有单继承，没有多继承！即一个儿子只能有一个爸爸，而一个爸爸可以有多个儿子
  • 继承是类与类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
  • 继承关系的两个类，一个为子类(派生类)，一个为父类(基类)，子类继承父类，可以使用关键字extends来表示
  • 子类和父类之间，从意义上将应该有"is a"的关系
  • object类就是Java . lang文件中已定义好的一个方法，使用时无需进行继承声明
package Demo03;
//在Java中，所有的类，都默认直接或间接继承Object
public class Person /*extends Object*/{
    //优先级从上到下：
    //public 公开的权限，调用范围最广
    //protected 受保护的
    //default 默认的
    //private 私密的
    /*一般属性才是私有的，要想子类调用父类私有的属性，
    可以使用get/set 来进行调用
     */
    /*
    Ctrl+H 可以看继承树
     */
    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;
    }
}
/*
public static void main(String[] args) {
        Student s1 = new Student();
        s1.say();
        System.out.println(s1.money);

    }
 */

package Demo03;
//Student is a person :派生类、子类
//子类继承了父类，就会拥有父类的全部方法！(前提是修饰符都是public)
public class Student extends Person{

}
super-this
super注意点：
    1.super 调用父类的构造方法，必须在构造方法的第一个
    2.super 必须只能出现在子类的方法或者构造方法中
    3.super 和 this 不能同时调用构造方法(不能同时在第一行)
Vs this:
    代表的对象不同：
        this:本身调用者这个对象
        super:代表父类对象的引用
    前提:
        this:没有继承也可以使用
        super:只能在继承条件下才可以使用
    构造方法
        this():本类的构造
        super():父类的构造

子类：Student

package Demo04;

public class Student extends Person{
    //隐藏代码：调用了父类的无参构造

    private String name="renshengjihe";
    public Student(){
        //隐藏代码：默认调用了父类的无参构造
        //调用父类的构造器，必须要在子类构造器的第一行
       //super是隐藏代码
        super("hello");
        //this("hello");//无参构造调用有参构造，如果不在第一行也会报错
        System.out.println("Student无参构造执行了");

    }
    public Student(String name){
        this.name=name;
    }
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }
    public void test(String name){
        System.out.println(name);//对酒当歌
        System.out.println(this.name);//renshengjihe
        System.out.println(super.name);//duijiudangge
    }
}
/*
public static void main(String[] args) {
        Student student = new Student();
        //student.test("对酒当歌");
        //student.test1();
    }
 */

父类：Person

package Demo04;

public class Person {
    protected String name="duijiudangge";

    public Person(){
        System.out.println("Person无参构造执行了");
    }
    public Person(String name){
        System.out.println("Person有参构造执行了");
    }
    //私有的东西无法被继承 private
    public void print(){
        System.out.println("Person");
    }

}
方法重写

重写都是方法的重写，和属性无关

package Demo.Demo05;

public class A extends B{
    public void test(){
        System.out.println("A=>test()");
    }
}
    public static void main(String[] args) {
        //静态的方法不能重写
        //方法的调用只和子类的数据类型有关
        A a = new A();
        a.test();//A=>test()
        //父类的引用指向了子类，实际上调用的是子类的方法
        B b = new A();//父类的引用指向了子类的方法 指向的方法必须是public的 
        b.test();//A=>test()
    }

package Demo.Demo05;

public class B {
    public void test(){
        System.out.println("B=>test()");
    }
}
  • Application类
package Demo;

import Demo04.Person;
import Demo04.Student;
import ooc.Animal;
import ooc.Cat;
import ooc.Dog;

import java.util.Scanner;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("哈士奇");
        System.out.println(dog.getName());
        dog.eat();
        Cat cat = new Cat();
        cat.setName("黑猫警长");
        System.out.println(cat.getName());
        cat.eat();
        

    }
}
  • Animal(父类)
package ooc;
/*
    重写都是方法的重写，和属性无关
    方法重写：子类中出现了和父类中一模一样的方法声明
    重写条件：
        1.必须是继承关系
        2.子类和父类的方法名必须相同
        3.重写发生在两个类中(重载是发生在一个类中)
        4.修饰符：范围可以扩大，但不能缩小
        5.抛出的异常：范围可以被缩小，但不能被扩大 	
    重写好处：当子类需要父类的功能，而功能主体子类有自己的特定内容时，
    可以重写父类中子类的方法，这样既沿袭了父类的功能，
    又定义了子类特有的内容
    注意：子类如果想调用父类方法，直接在重写方法中使用super关键字即可

    重写的父类中的方法，方法的修饰符必须是公共有的，不能是private
 */

public class Animal {

    private String name;
    /*
    方法重写现象：在该类中eat方法和父类Animal中eat方法一样
     */
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void eat(){
        System.out.println("吃东西.....");
    }
}
  • Dog(子类1)
package ooc;

public class Dog extends Animal{
    @Override//方法重写注释
    public void eat() {
        super.eat();//调用了父类的方法
        System.out.println("狗吃热骨头.....");
    }
}
  • Cat(子类2)
	package ooc;

public class Cat extends Animal{
    @Override
    public void eat() {
        super.eat();
        System.out.println("猫吃鱼");
    }
}

以上四个类是非静态的方法重写，静态方法不能被重写！！！

多态

  • 即同一个方法可以根据发送对象的不同而采取多种不同的行为方式
  • 一个对象的实际类型是确定的，但是可以指向对象的引用类型有很多
多态注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类，多态必须有联系 不然会出现类型转换的异常！ ClassCastException
3. 多态存在条件：

- 继承关系
- 方法需要重写(即子类重写父类的方法)
- 父类的引用指向子类对象  Father f1=new Son();

  • 方法不能被重写的情况：

    • static 方法:属于类，不属于实例
    • final 常量;
    • private 方法；

Application

package Demo;

import Demo.Demo06.Person;
import Demo.Demo06.Student;

import java.util.Scanner;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

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

        //但是，可以指向的引用类型就不确定了：父类的引用类型指向子类的实际类型

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

        //父类中如果写了调用的方法，子类也可以直接使用，因为子类会继承父类的所有方法
        //子类中如果重写了父类的方法，则会都执行子类的方法
        //父类中如果没有写对应的方法，那么对应多态 Father f1=new Son();可以通过强制对象转换来实现方法的调用

        s1.run();
        s2.run();//子类重写了父类的方法，执行子类的方法

        //对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大！

        s1.eat();
        ((Student)s2).eat();
    }
}

Person

package Demo.Demo06;

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

Student

package Demo.Demo06;

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

instanceof 和对象类型转换

  • instanceof关键字可以判断一个对象是什么类型，只有存在继承关系的对象才会输出YES

Application

package Demo;

import Demo.Demo07.Person;
import Demo.Demo07.Student;
import Demo.Demo07.Teacher;

import java.util.Scanner;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类型之间的转换：基本类型转换(低转高)和强制类型转换(高转低)

        //  低转高    默认不需要类型转换
        //*Person student = new Student();
        //此时的student不能执行go()方法，因为此时的student是Person类型的，
        //若想通过student对象来执行go()方法，则需要进行类型转换
        //即将Person类型的 student 转换为Student 类型

        //将student这个Person类型对象转换为Student对象
        //方法01
        //*Student obj=(Student)student;
        //*obj.go();
        //方法02
        //*((Student)student).go();

        //子类转换为父类可能会丢失一些方法！
        Student student = new Student();
        Person person=student;
        //person.go();

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

Person

package Demo.Demo07;

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

}

Student

	package Demo.Demo07;

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

}
/*
  //Object>String
        //Object>Person>Student
        //Object>Person>Teacher
        Object object = new Student();
        //System.out.println( X instanceof Y);//能不能编译通过就是看X、Y之间是否存在父子关系


        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Student);//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 Object);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Student);//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 Object);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Student);//true
        //System.out.println(student instanceof Teacher);//编译报错
        //System.out.println(student instanceof String);//编译报错
 */

static关键字

  • Person类
package Demo.Demo08;

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();
        //匿名代码块
        //构造方法
    }
}
  • Student类
package Demo.Demo08;

public class Student {

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

    public void run(){
        go();//静态方法与类一起加载，非静态方法可以直接调用静态方法
    }
    public static void go(){

    }

    public static void main(String[] args) {
        /*
        Student student=new Student();
        System.out.println(Student.age);    //因为可以通过类来直接调用，因此age变量也被称为类变量
        System.out.println(student.age);
        System.out.println(student.score);

         */

        //调用非静态方法
        new Student().run();

        //调用静态方法
        //方法1：
        go();
        //方法2：
        Student.go();

    }
}
静态导入包和final修饰类
package Demo.Demo07;
//静态导入包
import static java.lang.Math.random;//import用来导入一个包
import static java.lang.Math.PI;//import用来导入一个包
public class Task {
    public static void main(String[] args) {
        //System.out.println(Math.random());//random是随机数
        System.out.println(random());//导入静态包后不会报错
        System.out.println(PI);

        //通过final修饰的类就不能进行继承了，就不能有子类了,
        //相当于final修饰过的类以后断子绝孙
    }
}

抽象类和接口

抽象类

  • abstract修饰符可以用来修饰方法，也可以用来修饰类。如果修饰方法，那么该方法就是抽象方法，如果是修饰类，那么该类就是抽象类

  • 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类

  • Animal类

package Demo.Demo09;

//abstract 抽象类：本质还是一个类 需要继承关系 且是单继承的
// java中没有多继承的，但是可以通过接口来实现多继承
public abstract class Animal {
    //约束（框架）：有人帮我们实现
    //abstrct,抽象方法，只有方法名字，没有方法的实现！（就是没有代码块）
    public abstract void DoSomething();
    /*
    抽象类的特点：
    1.不能new这个抽象类，只能靠子类来实现它：约束；
    2.抽象类中可以写普通的方法
    3.抽象方法必须在抽象类中
    抽象类就是 抽象的抽象：约束

    两个问题：
    1.抽象类虽然不能new对象，但是存在构造器
    2.抽象类存在的意义  将模块化的东西抽象出来  提高开发效率
     */
}
  • Dog类
package Demo.Demo09;

//抽象类的所有方法必须要由子类事项，因此需要重写父类的抽象方法
//除非子类也是一个abstract类，则要由子子类来实现
public class Dog extends Animal{
    @Override
    public void DoSomething() {

    }
}

接口

  • 普通类：只有具体实现

  • 抽象类：具体实现和规范(抽象方法)都有！

  • 接口：只有规范！自己无法写方法~专业的约束！
    约束和实现分离 ：面向接口编程

  • 接口的本质是契约，就像人间的法律一样，制定好之后必须遵守

  • OO(面向对象)的精髓就是对 对象 的抽象，接口是最能体现这一点的

  • UserService

package Demo.Demo10;

//使用接口时 需要改变class关键字定义为interface
//接口都需要有实现类
public interface UserService {
    //接口中所有的属性定义都默认为 public static final
    //在接口中所有的属性都是 final
     int AGE=99;
    //接口中所有的方法定义其实都是抽象(abstract)的 默认为public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
  • TimeService
package Demo.Demo10;

public interface TimeService {
    void timer();
}
  • UserServiceImpl
package Demo.Demo10;

//抽象类：extends
//接口：implements 通过类 可以实现接口
//实现了接口的类，就需要在该类中重写接口中的方法

//可以在一个类中连接多个接口来实现多继承
public class UserServiceImpl implements UserService, TimeService {
    @Override
    public void timer() {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

接口的作用：

1.接口是一个约束
2.可以在接口中定义一些方法，让不同的人实现
3.接口中的方法默认都是public abstract 
4.接口中的属性默认都是public static final
5.接口不能被实例化~因为接口不是类，接口中没有构造方法
6.implements可以实现多个接口
7.必须要重写接口中的方法

内部类

  • 内部类就是在一个类的内部再定义一个类，比如，A类中定义了一个B类，那么B类就称为内部类，A类就称为外部类

外部类和内部类

package Demo.Demo11;

public class Outer {
    private int id=10;
    private void out(){
        System.out.println("这是外部类的方法");
    }
    //内部类存在public class
    //内部类可以访问外部类的一些私有属性、私有方法

    

    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获取外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
        //获取内部类的私有方法
        public void getout(){
            out();
        }
    }
}
//一个java类中可以有多个class类，但是只能有一个public class类
class A{

}


package Demo;


import Demo.Demo11.Outer;

public class Application {
    public static void main(String[] args) {
        //new 来实现外部类
        Outer outer = new Outer();
        //outer.out();

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

静态内部类

//存在静态内部类，
// 此时若再去调用外部类的属性、方法时会报错
//因此需要再外部也加上public static
public static int id=10;
    public static void out(){
        System.out.println("这是外部类的方法");
    }
	public static class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }

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

        public void getout(){
            out();
        }
    }

内部类2

package Demo.Demo11;

public class Outer {

}

//一个java类中可以有多个class类，
// 但是只能有一个public class类
//内部类
class A{

}

局部内部类

package Demo.Demo11;

public class Outer {
    //局部内部类:方法中定义了一个类
    public void method(){
        class Inner{
            public void in(){

            }
        }
    }
}

匿名内部类

package Demo.Demo11;

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();
}

加粗样式

对 酒 当 歌 人 生 几 何
关注
Java 五种单例模式
OOC_ZC的博客
01-15 467
单例模式有以下特点： 1. 单例类只能有一个实例。 2. 单例类必须自己创建自己的唯一实例。 3. 单例类必须给所有其他对象提供这一实例。 单例模式确保某个类只有一个实例。单例模式实现有两种方式：1. 饿汉模式public class HungrySingle { //这里方法均为static，其他类可直接使用。 private static final Hung
Java 基础学习笔记
OOC_ZC的博客
03-19 954
基本类型自动转换 float f = 1.1 // 编译错误 “possible lossy conversion from double to float” 1.1默认是double类型，这里为向下转型（double -&amp;amp;amp;amp;gt; float），Java 不能隐式执行向下转型，但可以隐式执行向上转型。 float f = 1 // 编译通过 1默认为int类型，向上转型可以隐式执行。 float ...
Java 同步机制
OOC_ZC的博客
12-04 709
.
Java 注解
OOC_ZC的博客
06-18 235
概述 注解的优点包括：更加干净易读的代码，以及编译期类型检查。 注解的语法比较简单，除了@符号的使用之外，它基本与Java固有的语法一致。Java内置了三种注解，定义在java.lang中的注解： @Override，表示当前的方法定义将覆盖超类中的方法。如果你不小心拼写错误，或者方法签名对不上被覆盖的方法，编译器就会发出错误提示。 @Deprecated，如果程序员使用了注解为它的元素，那么编...
java_初识面向对象
PWQ002的博客
06-29 321
JAVA：初识面向对象 一、基本介绍 面向对象程序设计（英语：Object-oriented programming，缩写：OOP）是种具有对象概念的程序编程典范，同时也是一种程序开发的抽象方针。它可能包含数据、属性、代码与方法。对象则指的是类的实例。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性，对象里的程序可以访问及经常修改对象相关连的数据。在面向对象程序编程里，计算机程序会被设计成彼此相关的对象。——《维基百科》 伪代码： 类狗 开始 公有成员:
Java初识面向对象-类与对象
weixin_47234283的博客
05-16 597
​ c.当类中没有写构造方法时，系统会默认添加无参构造（无参数的构造方法）成员变量：类里，方法的外面的变量，并且系统会赋默认值，作用在整个类中。​ 类的作用：类相当于一个模板，刻画出具有相同属性和方法的对象。​ 类名 对象名 ：对象名属于引用，存的是对象在堆内存中的地址。​ 类：抽象的概念，把具有相同特征和操作的事物归为一类。​ 类：抽象的概念，把具有相同属性和方法的对象归为一类。局部变量：方法内的变量，系统不会赋默认值，作用在方法中。成员方法：属于对象的方法，必须使用对象调用。
Java 面向对象 初识
蓝正潇的博客
04-01 188
Java为面向对象编程，学习面向对象内容的三条主线 1.java类及类成员（属性，方法，构造器和构造方法） 2.面向对象的三大特征(封装和隐藏，继承，多态) 3.其他关键字（this,package,import） 学习内容 面向对象与面向过程 java语言的基本元素：类和对象 类的成员之一：属性 类的成员之二：方法 对象的创建和使用 再谈方法 面向对象的特征之一：封装...
初识Java面向对象
qq_50692350的博客
07-18 197
面向对象
java+初识面向对象+基础题目
07-14
Java面向对象基础题目解析 在本节中，我们将通过一系列的题目，深入探讨Java面向对象的基础知识。这些题目涵盖了Java中的面向对象编程的基本概念，包括类、对象、继承、多态、封装等。 题目一：Student类 在这个...
java第五章初识面向对象
12-26
Java面向对象基础知识 面向对象是Java语言的核心思想之一，本章节将详细介绍面向对象的概念、类的格式、方法、构造器和this关键字等相关知识点。 一、面向对象概念 面向对象是Java语言的设计模型之一，它强调对象...
【JAVA基础篇】面向对象的详细介绍
YOU__FEI的博客
07-29 571
面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。 面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事。...
【Java 面向对象】初识面向对象
巴掌大叔的博客
07-01 306
面向对象编程(Object-Oriented Programming, 简称 OOP)是一种编程范式。在面向对象编程中，有两个重要的概念：类：一类事物的统称（例如 动物 类）、对象：某个**类**中的实例（例如 狗、猫）
Java Object 类常用方法
OOC_ZC的博客
11-15 332
1. equals() ： 判断两个对象是否等价。 Object类的默认实现（直接检查是否为同一个对象的引用）： Object类equals()的默认实现并不能很好的体现equals()想要的功能。因为不指向同一个对象，两对象也可能等价（关键域相同）。 看String类equals()的实现： 这是一个标准的equals()的实现，大体思路是： 检查是否为同一个对象的引用，如果是直接返回 ...
Java-网络
最新发布
2301_81543552的博客
09-14 457
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
上传文件到钉盘流程详解
jspyth的博客
09-14 495
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 603
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
C++位图的实现与详解
2301_80468112的博客
09-09 657
在讲解位图之前我们先来看一道很经典的面试题。给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中。我们有以下两种种解决方法：1. 遍历，时间复杂度O(N)。（太慢）2. 排序(O(NlogN))，利用二分查找: logN。深入分析:解题思路2是否可行，我们先算算40亿个数据大概需要多少内存。
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 813
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
Java面向对象编程基础：填空、选择与简答题详解
《Java面向对象编程》练习题是一份针对初学者的Java编程教材配套练习，旨在帮助学生巩固和理解面向对象编程的基础知识。以下是从提供的部分内容提炼出的重要知识点： **专题1：初识Java** 1. Java的应用版本划分： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值