JAVA学习_week3

已于 2022-08-13 17:43:03 修改
阅读量224 收藏
点赞数 2
文章标签： 学习
于 2022-08-13 16:03:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58619750/article/details/126309990
版权

一、面向对象（上延续版）

 1、匿名对象

概念：即没有名字的对象

格式：new 类名（）;

匿名对象调用方法：new 类名().成员方法名();
好处：节省内存空间，在堆内产生，不需要从栈中开辟空间，使用完后立刻被jvm中的垃圾回收器回收

2、局部变量和成员变量的区别

1)代码位置
成员变量：类中，方法外
局部变量：一般在方法之内
2）内存中的位置
成员变量：堆内存中，和new有关
局部变量：占内存中，和方法有关
3）生命周期不同
成员变量：随从对象的创建而存在，对象创建完毕后会被jvm中的垃圾回收器回收
局部变量：随着方法的调用而存在，当方法使用结束而消失
4）初始值
成员变量：系统会给成员变量进行默认的初始化，String的初始值为null，int的初始值为0
局部变量：必须进行初始化赋值

3、this的认识

this：用来提供本类中地址值的引用、

举例：

public class Student {
    private String name ; //姓名
    public void setName(String name){
    this.name = name ;         //等号右边，指向该类（Student）的地址，等号左边为set接收的数据
    }
    public String getName(){
        return  name ;
    }
}

 4、一个类的成员方法

类的成员变量：描述这个类有哪些属性

类的成员方法：setXXX()/getXXX():赋值和获取值的方法

类的构造方法 
1）这个方法名和类名相同
2）这个方法没有void
3）构造方法可以重载：分为有参/无参构造方法

构造方法的目的：为了方便成员相关数据进行初始化

注意：当一个类中没有构造方法的时候，系统会默认提供一个无参构造方法（不显示在代码中），但，如果系统中已经有了一个有参构造方法了，此时系统不会提供无参构造方法，需要自己手动输入一个无参构造方法

一个标准类的写法：

        成员变量私有化

        成员获取值和输出值的方法（setXXX()/getXXX()）
        提供有参/无参构造方法 

public class Phone {

    private String brand ; //品牌
    private int price ; //价格
    private String color ; //颜色
    private String memoryCache ;//内存

    //无参构造方法
    public Phone() {
    }
    //有参构造方法
    public Phone(String brand, int price, String color, String memoryCache) {
        this.brand = brand;
        this.price = price;
        this.color = color;
        this.memoryCache = memoryCache;
    }

    //对外的公共访问方法setXXX()/getXXX()
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getMemoryCache() {
        return memoryCache;
    }

    public void setMemoryCache(String memoryCache) {
        this.memoryCache = memoryCache;
    }
    //打电话
    public void callPhone(String toName){
        System.out.println(brand+"可以给"+toName+"打电话");
    }
    //发短信
    public void sendMsg(String toName){
        System.out.println("可以给"+toName+"发短信了...");
    }
}

5、static关键字 

定义：是一种属性的描述，可以是变量，可以是方法（静态的，静止的）

特点：
1）被静态修饰的随着类的加载而价值，优先于对象
2）不能和this一起使用
3）本身含义结束共享，公用；可以多个对象公用

静态的使用范围：静态只能访问静态。

6、代码块

分类：静态代码块，构造代码块，构造方法

优先级：静态代码块>构造代码块>构造方法

举例：

class Root {
    static {
        System.out.println("Root的静态初始化块");//1
    }
    {
        System.out.println("Root的普通初始化块");//4
    }
    public Root() {
        System.out.println("Root的无参数的构造器");//5
    }
}
class Mid extends Root {
    static {
        System.out.println("Mid的静态初始化块");//2
    }
    {
        System.out.println("Mid的普通初始化块");//6
    }
    public Mid() {
        System.out.println("Mid的无参数的构造器");//7
    }

    public Mid(String msg) {
        this();
        System.out.println("Mid的带参数构造器，其参数值：" + msg);//8
    }
}

class Leaf extends Mid {
    static {
        System.out.println("Leaf的静态初始化块");//3
    }

    {
        System.out.println("Leaf的普通初始化块");// 9
    }

    public Leaf() {
        super("hello");
        System.out.println("Leaf的构造器");//10
    }
}

public class LeafTest {
    public static void main(String[] args) {
        new Leaf();
    }
}

二、面向对象（中）

1、继承

定义：将多个类的共性内容抽取出来，房子一个独立的类中，让这个类和其他类产生一种关系就叫做继承 

格式：

class 父类名{    
    共性内容：姓名，年龄
    父类中的方法setXXX/getXXX等
}
class 子类名 extends 父类名{}

 继承的好处：
1）可以提高代码的复用性
2）可以提高代码的维护性
3）类与类的继承关系，是后面“多态”的前提条件

特点：
1）继承只能接受单继承，不能多继承
2）虽然不能多继承，但是可以多层继承

举例：

class A{
    public void show1(){
        System.out.println("第一继承");
    }
}
class B extends  A{
    public void show2(){
        System.out.println("第二继承");
    }
}
class C extends  B{
    public void show3(){
        System.out.println("第三继承");
    }
}
public class ExtendsDemo {
    public static void main(String[] args) {
        C c = new C() ;
        c.show3();    //c本身的方法
        c.show2();    //寻找B的方法
        c.show1();    //A的方法
    }
}

 2、重写

引入：子类在调用父类方法时有两种情况
情况一：子类方法和父类方法名不相同，可以分别直接调用；
情况二：子类方法和父类方法名相同时：权限修饰符，返回值类型，参数列表都一样时，如果主函数使用了该方法，则会发生子类方法将父类方法覆盖的情况--->方法重写
override

举例：

class A {
    public void show(){
        System.out.println("我是A");
    }
}
class B extends A{
    public void show(){
        System.out.println("我是B");
    }
}
public class Demo{
    public static void main(String[] args) {
        B b =new B();
        b.show();  //此时父类和子类的方法名相同，则会出现子类方法将父类方法覆盖，输出应为：我是B
    }
}

3、final关键字 

 本身含义：最终的，无法更改的

 特点：
1）final可以修饰类，该类不能被继承
2）final可以修饰变量，此时这个变量是一个”常数“
3）final可以修饰成员方法，被修饰的方法不能被子类重写

class A {
    final int a = 20;
    public void show(){
        int a =30;
    }

}
class B extends A {

}
public class FinalDemo {
    public static void main(String[] args) {
        B b =new B();
        b.show();
        System.out.println(b.a);

    }
}

三、面向对象（下）

1、多态

1.什么是多态

宏观角度：一个事务在不同时刻体现的状态不同
微观角度：具体对象在内存中的变化

2.多态的前提条件

1）必须有继承关系，无继承，不提多态
2）必须存在方法重写
3）必须存在父类引用子类对象
格式：

父类名 对象名  = new 子类名() ;   //向上转型:使用的父亲的东西

3.多态的成员访问特点（很重要） 

1）成员变量：编译看左，运行看左；
2）成员方法：编译看左，运行看右； 
3）构造方法：多态的前提条件，有继承关系，跟继承一样，分层初始化先执行父类的构造方法，然后进行子类的构造方法

4.多态的弊端

当多态的前提条件满足后，出现了多态的弊端
无法调用子类的特有功能！

解决方法1，重新创建自己的子类对象
解决方法2，
向下转型：
格式：

前提必须向上转型Fu fu = new Zi() ;
Zi z  = (Zi)fu ;  //强转的语法

5.多态的好处

1）提高代码的复用性，由继承保证
2）提高代码的延展性，由多态保证

实例：

class Animal{
    public void eat(){
        System.out.println("动物都需要吃饭");
    }
    public void sleep(){
        System.out.println("动物都需要休息");
    }
}
class Dog extends  Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("狗侧着睡");
    }
    public void lookDoor() {
        System.out.println("狗看门");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    @Override
    public void sleep() {
        System.out.println("猫躺着睡");
    }
    public void catch() {
        System.out.println("猫抓老鼠");
    }
}
public class DuoTaiDemo {
    public static void main(String[] args) {
        Animal a = new Cat() ;
        a.eat();
        a.sleep();
        Cat c =(Cat) a;
        c.catch();

        Animal a2 = new Dog() ;
        a2.eat();
        a2.sleep();
        Dog d =(Dog) a2;
        d.lookDoor();
    }
}

2、抽象类

1.什么是抽象类？

定义：在一个类中，如果由抽象方法，这个类必须为抽象类

2.抽象的方法格式：

根据写方法的格式一样,加入一个关键字abstract,而且没有方法体{}
public abstract 返回值类型 方法名(空参/带参) ;

3.抽象类的特点

1）不能实例化（不能创建对象）
2）必须强制子类进行抽象方法重写

4.抽象类的成员特点：

1）成员变量：抽象类的成员变量可以是常量（被final自定义）/变量
2）成员方法：可以是抽象类方法也可以是非抽象类方法
3）构造方法：可以定义无参/有参

abstract class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public abstract void eat();
    public abstract void sleep();
}
class Student extends Person{
    private String sno;


    public Student (){

    }

    public Student(String name, int age, String sno) {
        super(name, age);
        this.sno = sno;
    }

    public String getSno() {
        return sno;
    }

    public void setSno(String sno) {
        this.sno = sno;
    }

    @Override
    public void eat() {
        System.out.println(getName()+"喜欢吃辣条");
    }

    @Override
    public void sleep() {
        System.out.println(getName()+"在学校宿舍睡觉");
    }
    public void study(){
        System.out.println(getName()+"说，我爱学习");
    }
}
class Worker extends Person{
    private String wno;

    public Worker() {
    }

    public Worker(String name, int age, String wno) {
        super(name, age);
        this.wno = wno;
    }

    public String getWno() {
        return wno;
    }

    public void setWno(String wno) {
        this.wno = wno;
    }

    @Override
    public void eat() {
        System.out.println(getName()+"喜欢吃肉");
    }

    @Override
    public void sleep() {
        System.out.println(getName()+"在工地宿舍休息睡觉");

    }
    public void work(){
        System.out.println(getName()+"说，我爱工作");
    }
}
public class PersonTest {
    public static void main(String[] args) {
        Person p =new Student("张三",18,"学生001");
        Student s = (Student) p;
        System.out.println(p.getName()+"---"+p.getAge()+"---"+s.getSno());
        p.eat();
        p.sleep();
        s.study();
        System.out.println("--------------------------------------------");
        Person p2 =new Worker("李四",29,"工人001");
        Worker w = (Worker) p2;
        System.out.println(p2.getName()+"---"+p2.getAge()+"---"+w.getWno());
        p2.eat();
        p2.sleep();
        w.work();
    }
}

3、接口

1.什么是接口？

接口体现的是事务的一种额外功能

2.格式

interface  接口名{   //命名规范和类名命名一样,见名知意 "大驼峰命名法"
    只能为抽象方法
}
接口的子类----"子实现类"
class 子类名  implements  接口名{//实现类必须实现接口的抽象方法,否则报错

}
//接口比抽象类还抽象

2.特点

接口最大的特点：不能实例化

3.接口的成员特点

1）成员变量：只能是常量，存在默认修饰符：public static final
2）成员方法：之你呢个是抽象方法，存在默认修饰符：public abstract
3）构造方法：没有构造方法

 实例：

interface Area {
    void calculateArea();
}
class MyCircle implements Area{
    private double radius;

    public MyCircle() {
    }

    public MyCircle(double radius) {
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    @Override
    public void calculateArea() {
        System.out.println("圆的面积为："+(3.14*getRadius()*getRadius()));

    }
}
class MyRectangle implements Area{
    private double length;
    private double width;

    public MyRectangle() {
    }

    public MyRectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    @Override
    public void calculateArea() {
        System.out.println("矩形的面积为"+(getLength()*getWidth()));

    }
}
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        System.out.println("-----------圆形-------");
        System.out.print("请输入圆的半径：");
        double a = sc.nextDouble();
        Area a1 =new MyCircle(a);
        a1.calculateArea();
        System.out.println("-----------矩形-------");
        System.out.println("请输入矩形的长和宽：");
        double b = sc.nextDouble();
        double c = sc.nextDouble();
        Area b2 =new MyRectangle(b,c);
        b2.calculateArea();
    }
}

四、对面向对象中的几个问题

1、关于Java中面向对象牵扯关系问题

Java中最基本的单位：类

类和类：继承关系 extends,Java中只支持单继承和多层继承，不支持多继承

类和接口：实现关系implement 一个类可以实现多个接口

接口与接口：继承关系 extends

2、 在使用多态是出现ClassCastException，说明了什么？

ClassCastException属于运行事情异常的一种：代表“类转换异常”
使用多态操作向下转型时使用不当，堆内存中信息和占内存信息没有父子关系

3、abstract不能和那些关键字使用 

static：静态方法算不上方法重写
private：因为abstract需要被重写，所以不能私有
final：被final修饰的成员方法不能被重写，违背了抽象类的要求 

4、super关键字，和this的关系 

super:代表父类的空间标识(代表父类的地址值引用)

 区别：
1）
this.变量名           访问本类的成员变量
super.变量名        访问父类的成员变量
2）
this.方法名()        访问本类的成员方法
super.方法名()      访问父类的成员方法
3）
this()                      访问本类无参构造方法
super()                  访问父类的无参构造方法
4）
this(xxx)                访问本类的有参构造方法
super(xxx)             访问父类的有参构造方法 

5、接口和抽象类的区别

从定义来说：
this:用来提供本类中地址值的引用
super:用来提供空间上的地址值(即,父类的地址值的引用)

区别：

成员变量: 抽象类:可以是变量,也可以是自定义常量
                 接口: 成员变量只能是常量.
成员方法 :抽象类: 抽象方法/非抽象方法
                 接口:只能是抽象方法
构造方法: 抽象类 :无参构造,有参构造都可以存在 存在继承关系,分层初始化
                 接口:无构造方法.
抽象类用 entends      

接口用implements 

6、什么是方法重写 ，什么是方法重载

方法重写:出现在继承中,描述子类继承父类时,当父类方法与子类方法名重名时,子类方法将覆盖掉父类方法
方法重载:方法定义的时候,方法名相同,参数列表不同,与返回值无关,

7、方法的形式参数如果是引用类型和基本类型

为基本类型时:只需要在括号内输入基本类型数值即可

为引用类型时:需要传递是当前类的具体类对象

青山枫叶
关注
java简单练习
weixin_53058293的博客
11-25 250
对象数组练习
每日作业 - JavaSE第7天
FreeSpider
10-19 2277
知识点 面向对象 题目1（训练） 定义手机类，手机有品牌(brand),价格(price)和颜色(color)三个属性，有打电话call()和sendMessage()两个功能。 请定义出手机类，类中要有空参、有参构造方法，set/get方法。 定义测试类，在主方法中使用空参构造创建对象，使用set方法赋值。 调用对象的两个功能，打印效果如下： 正在使用价格为3998元黑色的小米手机打电话.......
手机类的练习
JIE结弦的博客
10-24 1745
定义手机类： 手机有品牌(brand),价格(price)和颜色(color)三个属性; 需要进行私有化操作; 有打电话call()和sendMessage()两个功能 类中要有set/get方法。 定义手机测试类： 在主方法中分别使用有参和空参创建对象。 提供set和get方法。 调用对象的两个方法使用功能。 手机类代码实现： public class Phone { //定义成员变量,私有化 private String brand,color; priva
死磕Lambda表达式（五）
java100001的博客
05-04 90
*/ private double price; public String getBrand() { return brand; } public void setBrand(String brand) { this.brand = brand; } public String getType() { return type; } public void setType(String type) { this.type = type; } public double getPrice() { return
java中Condion
qq_43488287的博客
12-05 442
Condition是在Java1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。 它的更强大的地方在于：能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition 一个Condition包含一个等待队列。一个Lock可以产生多个Condit
JAVA学习_week2
m0_58619750的博客
08-06 178
初学Java的第二周总结
Java_week6
weixin_30569153的博客
08-19 125
注释 <!-- --> 代码： 　　 结果： 1.默认情况下，浏览器会将“<”当做标签的一个组成部分对待，但我们希望不是标签的组成部分，而是真正 的小于号，这是我们要用一个技术去代替这些特殊的字符，该技术在HTML中叫实体，类似于Java中的转义符。 加载并播放本地音乐 Width 和 height是...
Java_week8
weixin_30551947的博客
09-02 122
　　本周开学，进入小学期，整天在思考程序，脑子有点跟不上，Java学习暂时搁置。 转载于:https://www.cnblogs.com/janeszj/p/9574478.html
Java_week5
weixin_30508241的博客
08-12 120
　　 Static 是一个修饰符，用于修饰成员（成员变量，成员函数） 当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。类名.静态成员 Jvm :虚拟机 Jvm 在调用主函数时，传入的是new String[0]; 因为学习JAVA基础，感觉跟不上进度所以抓紧学习基础的同时，学习其他内容。 Html:网页语言 由标签组成 Body 中...
java_week10
03-08
在本周的Java学习主题"java_week10"中，我们将深入探讨Java编程语言的一些核心概念和技术，这将有助于提升你的编程技能和理解力。在这个压缩包文件中，包含的子文件名为"java_week10-main"，这通常代表这是一个项目...
week1_code_javaprogramming_java_bluej_
09-29
总之，“week1_code_javaprogramming_java_bluej_”的学习资料将引导你踏入Java编程的世界，通过BlueJ的辅助，你将能够逐步理解并掌握面向对象编程的基本原理和技巧。祝你在编程之旅中取得成功！
week4_code_javaprogramming_java_bluej_
09-29
"week4_code_javaprogramming_java_bluej_" 这个标题暗示了这是一个关于Java编程的学习资源，可能是一个课程或教程的第四周代码示例。BlueJ是一个专门为初学者设计的Java集成开发环境（IDE），它以其直观的可视化...
lab_exercises_week_6:lab_exercises_week_6
07-14
【标题】"lab_exercises_week_6:lab_exercises_week_6" 指的可能是一份关于Java编程的学习资源，特别关注第六周的实验练习。这个标题表明这是一个与编程教育相关的项目，其中包含了第六周实验室课程的练习题目或者...
贪吃蛇的java简单源码-Engineering_84_business_week:Engineering_84_business_week
06-07
3：为什么选择 Sparta Global？ 问题 4：Scrum 是什么以及实施它的好处是什么？ 问题 5：您在 2-5 年之后如何看待自己？ 问题 6：DevOps 是什么以及使用它的好处是什么？ 问题7：Scum的三个角色是什么？ 问题 8：...
ORB-SLAM2源码学习：ORBextractor.cc：IC_Angle 利用灰度质心法求解关键点方向角
2301_76831056的博客
11-01 440
IC_Angle 利用灰度质心法求解关键点方向角并在computeOrientation函数中被调用计算图像中所有特征点的方向。
点云学习笔记3——读取点云文件、进行统计滤波/直通滤波后可视化
qq_64095888的博客
10-29 180
【代码】点云学习笔记3——读取点云文件、进行统计滤波后可视化。
diffusion model 学习笔记
最新发布
wubing's 博客
11-01 582
郎之万公式: 描述了粒子做随机布朗运动 (粒子位置随时间变化的关系), 是一种 SDE, 描述了 由梯度力(即.即我们在无条件模型 DDPM 估计的噪声中添加一个微小的扰动(. 基本上,在采样一半时,基本上预测的。输出的是噪声的估计, 这个估计的噪声。通过上面的公式，我们可以知道，当知道。),就可以作为条件模型的噪声估计.首先,假设我们已经有了一个训练好的。: 每一步中保留的原始信号的比例。的计算有各种不同的方法，). 已经接近于真实的。)影响的系统的时间演化.也就是,我们训练的网络。
jsp web学习二(比较老的啦)
qq_52122048的博客
10-29 1039
JavaBean模式(MVC)适合开发复杂的web应用，在这种模式下，servlet负责处理用户请求，jsp负责数据显示，javabean负责封装数据。Servlet+JSP+JavaBean模式程序各个模块之间层次清晰，web开发推荐采用此种模式。一个良好的JavaWeb项目架构应该具有以上的11个包，这样显得层次分明，各个层之间的职责也很清晰明了，搭建JavaWeb项目架构时，就。
学习力体系
m0_46221544的博客
10-29 342
在一个小镇上，有一位年轻的学者小明，梦想成为一名科 学家。然而，他总是感到学习困难，知识无法长久保持。有一天，他遇到了一位智者，智者告诉他：“学习的力量能够改变命运。”小明意识到，提升学习力是实现梦想的关键，从此开始探索学习方法的旅程。通过以上方法，小明的学习能力不断提升，最后实现了自己的梦想。每个人都可以通过这些方法来加强自身的学习力，迎接更加美好的未来。怎样才能让知识长久保持？如何有效地提升学习力？
Java编程入门教程：使用BlueJ进行学习
本资源中的"week1_code"文件夹可能包含了第一周的学习内容，例如： 1. Java基本语法介绍：如何定义类、创建对象、编写方法等。 2. 简单的Java程序示例：比如"Hello, World!"程序。 3. 实践操作：通过实际编写代码，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值