java学习笔记（九）

已于 2022-03-14 10:56:11 修改
阅读量696 收藏
点赞数
文章标签： java 学习 开发语言
于 2022-03-14 10:54:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37612900/article/details/123241280
版权

java学习笔记（九）

开始学习java，并养成写博客的习惯，希望能够坚持下去,有志同道合的小伙伴可以一起学习java基础

二十四、封装、继承、多态

封装

禁止直接访问一个对象中数据的实际表示，应当通过操作接口来访问，这称为信息隐藏。

封装的核心：属性私有

package mifan.oop.Demo04;
//类
public class Student {

    private String name; //名字

    private int id;//学号

    private int age;//年龄

    private char sex;//性别

    //提供一些可操作这个属性的方法
    //提供一些public的get、set方法

    //get 获得这个数据
    public String getName(){
        return this.name;
    }

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

    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 mifan.oop;

import mifan.oop.Demo03.Pet;
import mifan.oop.Demo04.Student;

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

//        Pet dog = new Pet();
//        dog.name = "旺财";
//        dog.age = 3;
//        dog.shout();
//
//        System.out.println(dog.age);
//        System.out.println(dog.name);

        Student s1 = new Student();
        s1.setName("mifan");
        System.out.println(s1.getName());

        s1.setAge(-1);
        System.out.println(s1.getAge());
    }
}

继承

  • 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
  • extands “扩展” 子类是父类的扩展
  • JAVA只有单继承（一个儿子一个爸爸，一个爸爸多个儿子）
  • 继承是类与类之间的一种关系，除此之外还有其他关系，比如：依赖、组合、聚合等
  • 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
  • 子类和父类之间，从意义上讲应该具有“子类 is a 父类”的关系
  • java中所有类都默认继承object类
package mifan.oop;

import mifan.oop.Demo03.Pet;
import mifan.oop.Demo05.Student;

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

        Student student = new Student();
        student.say();//子类继承父类，会拥有父类的全部方法()
        //public
        //protected
        //default
        //public

    }
}


package mifan.oop.Demo05;

public class Person {
    public void say(){
        System.out.println("我说话了");
    }
}

package mifan.oop.Demo05;
//学生 is 人
public class Student extends Person{
        //CTRL+ H 打开继承树结构
}

super

super 用于子类调用父类（父类私有变量除外）

package mifan.oop;

import mifan.oop.Demo03.Pet;
import mifan.oop.Demo05.Student;

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

        Student student = new Student();
        student.test1();
    }
}


package mifan.oop.Demo05;
//学生 is 人
public class Student extends Person{
        //CTRL+ H 打开继承树结构
        private String name = "qq";
        public void print(){
            System.out.println("student");
        }
        public void test1(){
            print();
            this.print();
            super.print();
        }

}


package mifan.oop.Demo05;

public class Person {
    public void say(){
        System.out.println("我说话了");
    }

    protected String name = "mifan";

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

super注意点：

  1. super调用父类的构造方法，必须在构造方法的第一个位置
  2. super 只能出现在子类的方法或者构造方法中
  3. super 和 this 不能同时调用构造方法
  4. 父类存在有参构造，子类想要调用父类的无参构造时，父类必须显式定义无参构造

子类无参构造会自动调用父类的无参构造

package mifan.oop;

import mifan.oop.Demo03.Pet;
import mifan.oop.Demo05.Student;

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

        Student student = new Student();

    }
}


package mifan.oop.Demo05;
//学生 is 人
public class Student extends Person{

    public Student() {
        //此处存在隐藏代码，调用父类的无参构造
        System.out.println("student");
    }
}


package mifan.oop.Demo05;

public class Person {
    public void say(){
        System.out.println("我说话了");
    }

    //无参构造
    public Person() {
        System.out.println("person");
    }

    protected String name = "mifan";

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

方法重写

  1. 方法名必须相同
  2. 参数列表必须相同
  3. 修饰符范围可以扩大 public>protected>default>private
  4. 只有非静态方法存在重写
  5. 抛出异常范围可以被缩小，不能扩大
  6. 重写快捷键 alt + insert overide

1.静态方法

package mifan.oop;

import mifan.oop.Demo05.A ;
import mifan.oop.Demo05.B ;

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

        //方法的调用只和左边定义的数据类型有关
        A a = new A();
        a.test();
        //父类的引用指向子类
        B b = new A();
        b.test();
    }
}


package mifan.oop.Demo05;

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


package mifan.oop.Demo05;
//重写都是方法的重写，跟属性无关
public class B {
    //静态方法
        public static void test(){
            System.out.println("B=>test");
        }
}

2.非静态方法重写

package mifan.oop;

import mifan.oop.Demo05.A ;
import mifan.oop.Demo05.B ;

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

        //静态方法的调用只和左边定义的数据类型有关
        A a = new A();
        a.test();
        //父类的引用指向子类
        B b = new A();//子类对父类进行重载
        b.test();
    }
}


package mifan.oop.Demo05;
//重写都是方法的重写，跟属性无关
public class B {
    //非静态方法
        public void test(){
            System.out.println("B=>test");
        }
}


package mifan.oop.Demo05;

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

多态

  • 同一种方法可以根据发送对象不同而采取多种不同的行为方式
  • 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
  • 多态存在的条件
    • 有继承关系
    • 子类重写父类方法
    • 父类引用指向子类的对象
  • 多态是方法的多态，不是属性的多态
package mifan.oop;

import mifan.oop.Demo05.A ;
import mifan.oop.Demo05.B ;
import mifan.oop.Demo06.Person ;
import mifan.oop.Demo06.Student ;
public class Application {
    public static void main(String[] args) {
        //一个对象实际类型是确定的，但是可以指向的引用类型是不确定的，父类的引用指向子类
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();//Person类的父类

        s2.run();
        s1.run();
        //s1可以调用Person和Student的方法
        //s2可以调用Person ，不可以调用Student的方法
        s1.eat();
        //s2.eat(); 对象能执行哪些方法，主要看对象左边的类型
        ((Student)s2).eat();//强制转换Person类为Student类
    }
}


package mifan.oop.Demo06;

public class Person {

    public void run(){

    }
}

package mifan.oop.Demo06;

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

二十五、引用类型转换 instanceof

x instanceof y ，x 和 y 之间要有继承关系才行

package mifan.oop;

import mifan.oop.Demo05.A ;
import mifan.oop.Demo05.B ;
import mifan.oop.Demo06.Person ;
import mifan.oop.Demo06.Student ;
import mifan.oop.Demo06.Teacher;

public class Application {
    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 Teacher);//与Student是兄弟类
        System.out.println(object instanceof String);//String 是 Object下的类 编译通过 ,但是与Student无关 False
        System.out.println("****************");
        Person person = new Student();
        System.out.println(person instanceof  Student);
        System.out.println(person instanceof  Person);
        System.out.println(person instanceof Teacher);//Teacher与Person是父子类 ,编译通过,Teacher与Student不是父子类False
 
    }
}


package mifan.oop.Demo06;

public class Person {

    public void run(){

    }
}


package mifan.oop.Demo06;

public class Teacher extends Person{
}


package mifan.oop.Demo06;

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

1.父类引用指向子类对象，反之不行
2. 子类转换父类，向上转型
3.父类转换子类，向下转型，强制转换
4.方便方法的调用，减少重复的代码，简洁

package mifan.oop;

import mifan.oop.Demo05.A ;
import mifan.oop.Demo05.B ;
import mifan.oop.Demo06.Person ;
import mifan.oop.Demo06.Student ;
import mifan.oop.Demo06.Teacher;

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

        Student student = new Student();
        student.go();
        //类型转化: 父 子
        //高                  //低
        Person person = new Student();
        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法了
        ((Student) person).go();
        // 子 转换 父类
        Person person1 = student;
       // person1.go;//子类转换成父类，可能丢失自己本来的方法
    }
}


package mifan.oop.Demo06;

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

    }
}

二十六、static关键字

package mifan.oop.Demo07;

public class Student {

    private static int age; //静态的变量
    private double score;  //非静态的变量
// 静态方法是属于类的，动态方法属于实例对象，
// 在类加载的时候就会分配内存，可以 通过类名直接去访问
// 非静态成员（变量和方法）属于类的对象，
// 所以只有该对象初始化之后才存在，然后通过类的对象去访问。
// 也就是说如果我们在静态方法中调用非静态成员变量会超前，
// 可能会调用了一个还未初始化的变量。因此编译器会报错。
    public void run(){

    }

    public static void go(){

    }
    public static void main(String[] args) {
        go();

        //run(); 非静态方法不可以被静态调用
        
        Student s1 = new Student();


        System.out.println(Student.age);
        //System.out.println(Student.score);//未初始化，不能调用非静态变量
        System.out.println(s1.score);
        System.out.println(s1.age);
    }
}
  • 静态代码块：最先执行，只执行一次
  • 匿名代码块：构造方法之前执行，每次都执行
package mifan.oop.Demo07;

public class Person {
    {
        //代码块（匿名代码块）
        System.out.println("匿名方法");
    }

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

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

    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("==============");
        Person person2 = new Person();
    }
}
  • 静态导入工具包
package mifan.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 );
    }
}
  • final关键字的类，不能被继承

二十七、抽象类

  • 抽象类的所有方法，继承它的子类
  • 抽象类只能单继承，接口可以多继承
  • 不能new抽象类
  • 抽象类可以写普通方法，抽象方法必须在抽象类中
  • 抽象类可以有构造方法，只是不能直接创建抽象类的实例对象而已。在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法
package mifan.oop;

import mifan.oop.Demo05.A ;
import mifan.oop.Demo05.B ;
import mifan.oop.Demo06.Person ;
import mifan.oop.Demo06.Student ;
import mifan.oop.Demo06.Teacher;
import mifan.oop.Demo07.Action;

public class Application {
    public static void main(String[] args) {
       // new Action();//不能new抽象类，只能new它的子类
    }
}


package mifan.oop.Demo07;

//抽象类 abstract
public abstract class Action {
    public abstract void doSomething();//抽象方法，只有方法名字，没有方法实现
    //抽象类的所有方法，继承它的子类
    //抽象类只能单继承，接口可以多继承
    //不能new抽象类
    //抽象类可以写普通方法，抽象方法必须在抽象类中
    //抽象类可以有构造方法，只是不能直接创建抽象类的实例对象而已。在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法
}


package mifan.oop.Demo07;

public class A extends Action{
    @Override
    public void doSomething() {
        System.out.println("aaa");
    }
}

二十八、接口

  • 接口的本质是契约
  • 接口中的所有方法的定义都是抽象的 public abstract 可以省略
  • 接口中属性的定义使用 public static final，属性必须实例化
  • 接口不能被实例化，没有构造方法
  • 接口的实现使用implements ，可以实现多继承
  • 如果一个类中，既有抽象方法，又有非抽象方法，那么该类只能定义为抽象类，不能定义为接口
  • 如果一个类中，只有抽象方法，没有非抽象方法，那么该类可以定义为接口
package mifan.oop.Demo09;
//interface 定义的关键字 ,接口都需要有实现类
public interface UserService {
    //常量 public static final
    int AGE = 99;

    //接口中的所有定义都是抽象的 public abstract 可以省略
    public abstract void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);


}


package mifan.oop.Demo09;
//interface 定义的关键字，接口都需要有实现类
public interface TimeService {

    public abstract void test();
}


package mifan.oop.Demo09;
//类 可以实现接口 implements 接口
//抽象类 extends~
//实现了接口的类，就需要重写接口中的方法
//java可以利用接口实现多继承，
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 test() {

    }
}

二十九、N种内部类

1.内部类

package mifan.oop;

import mifan.oop.Demo05.A ;
import mifan.oop.Demo05.B ;
import mifan.oop.Demo06.Person ;
import mifan.oop.Demo06.Student ;
import mifan.oop.Demo06.Teacher;
import mifan.oop.Demo07.Action;
import mifan.oop.Demo10.Outer;
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类~
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.get();
    }
}


package mifan.oop.Demo10;

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

    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        public void get(){
            //获得外部类的属性
            System.out.println(id);
            Outer outer = new Outer();
            outer.out();
        }
    }
}

每一个牛逼人都有一段苦逼的时光，只要能像傻逼一样坚持下去，终会牛逼! 加油！

要靠技术恰饭的饭哥
关注
java person类_java写一个person类_java 编写一个Person类
weixin_35342955的博客
02-12 2259
最佳答案这是答案，这内容又相似了我服了1111111111111111111111111111111111111111111111111111111111111111这是person类package com.weng.xc;public class Person{//11111111111111111111111111111111public String name;//1111111111111...
Java学习笔记
Piglett的博客
12-30 1109
随着后续的学习还会不断地更新，并不仅仅包含Java基础，后续还会更新SSM，MySQL等内容。其记录了Java基础的学习内容，主要包括24集合到30动态代理（见语雀目录）。希望这篇笔记能够帮助到Java的学习，方便快速进行回顾复习。
Java 学习笔记
weixin_42098295的博客
05-13 2024
Java 是一种面向对象的编程语言，广泛应用于开发各种应用程序，包括 Web 应用程序、桌面应用程序、移动应用程序和嵌入式系统。Java 中有八种基本数据类型：byte、short、int、long、float、double、char 和 boolean。集合用于存储和组织数据。Java 中有各种控制流语句，用于控制程序流程，例如 if-else 语句、switch 语句和循环语句。Java 中有各种运算符，用于执行算术运算、比较运算、逻辑运算和位运算。I/O 用于从文件、网络和其他来源读取和写入数据。
java学习笔记（持续更新）
快乐学习，daydayup!
12-24 7713
如果您也在学习java，希望能够和您一起讨论，一起学习。这篇文章是记录笔者0基础学习java的过程，如果您阅读这篇文章时，发现一些错误，也希望您愿意指出。本次java学习流程以黑马程序员的java教学视频为主，其他博主或公开教程为辅。学习过程中遇到的一些个别情况或错误都会记录其中并记载解决方案。本篇学习记录会一直更新，希望能与大家一起学习，共同成长。
Java学习笔记 九、异常Exception
qq_43681634的博客
04-06 994
Java学习笔记 九、异常Exception
Java 学习笔记：面向对象
Li__Daxia的博客
03-19 1090
Java 学习笔记：面向对象
Thinking in Java读书笔记
热门推荐
yjclsx的博客
07-31 42万+
Thinking in Java读书笔记（IO和并发除外） 1.1、类中所有的private方法都隐式地指定为final的，由于其他类无法取用private方法，所以也就无法覆盖它；private方法无法被重写，继承对应private的方法无效，private的属性也无法拿到，但我们通常private的属性有对应的get、set方法，通常是public的，所以子类继承后可以调用方法来取得到父类的...
JAVA学习笔记（韩顺平老师）
2301_77385325的博客
04-19 1989
说明：本文为韩顺平老师的JAVA课程学习笔记，仅供自身学习参考，如有纰漏，请多指教，如有帮助，不胜荣幸。
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 25万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
Java学习笔记一
u013033706的博客
10-23 1528
Java学习笔记一1、Java语言的特点2、Java程序开发过程3、Java虚拟机JVM 学习方式： 书籍：《Java基础教程》 吴仁群 清华大学出版社 1、Java语言的特点 一种面向对象且与平台无关的多线程动态语言 2、Java程序开发过程 文件名.java产生applicationapplets源文件编辑器Java编译器字节码文件由Java解释器执行由Web浏览器执行 图1 Java程...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
java学习笔记java学习笔记java学习笔记java学习笔记
07-31
java学习笔记
(完整版)最全的java学习笔记(必看).pdf
05-27
Java学习笔记 Java是一种流行的编程语言，广泛应用于Android应用程序开发、Web应用程序开发、桌面应用程序开发等领域。以下是Java学习笔记的摘要信息： 一、Java技术基础 * 1.1 编程语言：Java是一种面向对象的...
Java学习笔记学习笔记
10-24
Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习...
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
Java-网络
2301_81543552的博客
09-14 805
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Java企业面试题3
m0_74972727的博客
09-15 865
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
JDK17新增语法特性
最新发布
2201_76124988的博客
09-20 511
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
上传文件到钉盘流程详解
jspyth的博客
09-14 819
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
JAVA学习笔记：入门篇
"Java学习笔记初步概述" 在Java学习的初期，我们首先会接触到的是Java程序的两种核心运行机制。Java程序的执行依赖于Java虚拟机（JVM），它负责将编译后的字节码文件转化为机器语言，使得Java代码能在不同的操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值