day10-java对象

最新推荐文章于 2024-09-25 10:59:43 发布
最新推荐文章于 2024-09-25 10:59:43 发布
阅读量393 收藏
点赞数
文章标签： java 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jzq_csdn_blog/article/details/114544691
版权

java对象

1.构造方法

//类
package com.codesing;

public class Person {
    String name;
    int age;
    char sex;

    //构造方法，类里默认有个无参构造方法
    //显示定义构造器
    //1.使用new关键字，本质实在调用构造器
    public Person() {
        this.name = "xiaoming";
        this.age = 23;
        this.sex = 'M';
    }

    //有参构造
    //一旦定义有参构造，无参构造必须显示定义
    public Person(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}
//主方法
package com.codesing;

public class Application {
    public static void main(String[] args) {
        Person xiaoming = new Person();
        System.out.println(xiaoming.name+xiaoming.age+xiaoming.sex);
        Person xiaohong = new Person("xh", 20, 'W');
        System.out.println(xiaohong.name+xiaohong.age+xiaohong.sex);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6fBFVKRX-1615202142047)(C:\Users\23236\AppData\Roaming\Typora\typora-user-images\image-20200914165935895.png)]

构造器：1.同类名相同，2.没有返回值

作用：1.new本质调用构造器。2.初始化对象的值

注意点：定义有参构造后，如果使用无参构造，显示定义无参构造

2.创建对象内存分析

//pet类
public class pet{
    public String name;
    public int age;
    
    public void shout(){
        System.out.prinln("叫");
    }
}
//创建对象
Pet dog = new Pet();
dog.name = "旺财";
dog.age = 3;
dog.shout();

Pet cat = new Pet();
System.out.prinln(dog.name);
System.out.prinln(dog,age);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lpw5WeGS-1615202142049)(C:\Users\23236\AppData\Roaming\Typora\typora-user-images\image-20200917000406634.png)]

  1. 首先在堆中方法区加载Application类，里里面有main方法和常量
  2. 执行main方法，在栈里，new Pet()时加载Pet类
  3. 生成dog对象，引用变量名在栈，对象体在堆中，此时为无参构造（name:null,age:0）
  4. 给dog对象赋值，（dog.name=“旺财”，dog.age=3）
  5. cat同上。
  6. main()方法结束，弹出栈，程序结束。

静态方法static和类一起加载，在类中可直接使用，对象可以直接调用

3.封装

私有属性：get/set

1.提高程序安全性，保护数据

2.隐藏代买实现细节

3.同一接口

4增加可维护性

package com.codesing;
//Car类
public class Car {
    private String name;//属性私有private,new完对象.name或.price获取不到值
    private int price;

    //get 得到这个数据
    //set 给这个数据设置值
    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {//这里可以做一些安全处理
        if (price > 5000000 || price <= 0) {
            this.price = 3;
        } else {
            this.price = price;
        }
    }

}
//主方法
Car car = new Car();
car.setName("法拉利");
System.out.println(car.getName());//法拉利
car.setPrice(-1);//3
System.out.println(car.getPrice());

4.继承

4.1 继承理解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1PH9NnDJ-1615202142051)(C:\Users\23236\AppData\Roaming\Typora\typora-user-images\image-20200917200641009.png)]

package com.codesing;
//java中所有的类，都默认或间接或直接继承Object
public class Car /*extends Object*/{
    //public方法
    public void say(){
        System.out.println("Car类");
    }
    public int money = 10_0000_0000;

    //object

}
//子类
public class Falali extends Car {

}
//子类
public class Baoshijie extends Car {

    //ctrl+h------->继承树
}
//主方法
Falali fi = new Falali();
Baoshijie baoshijie = new Baoshijie();
//可调用父类方法和属性
fi.say();
System.out.println(fi.money);

baoshijie.say();
System.out.println(baoshijie.money);

//object
Object o = new Object();
System.out.println(o.getClass());//很多方法

4.2 super和this

子类拥有父类所有方法，私有的东西无法被继承。

super注意点

  1. super用来调用父类的（非私有）方法和属性
  2. super()调用父类构造器，且在子类构造器第1行
  3. super必须只能出现在子类的方法或构造方法中
  4. super和this不能同时调用构造方法

VS this

  1. 代表对象不同： this本身调用者这个对象。super代表父类对象的应用
  2. 前 提 ： this无继承可使用。super只能在继承条件才可使用
  3. 构造 方法： this()本类的构造。super()父类的构造
package com.codesing;
//java中所有的类，都默认或间接或直接继承Object
public class Car /*extends Object*/{
    //protected
    protected  String name = "车子";
    public void print(){//私有的无法继承
        System.out.println("父类车子");
    }

}
//子类
public class Falali extends Car {
    String name = "法拉利";
    public void print(){
        System.out.println("子类车子");
    }
    public void test(String name){
        System.out.println(name);//保时捷
        System.out.println(this.name);//法拉利
        System.out.println(super.name);//车子
    }
     public void test1(){
        print();//子类车子
        this.print();//子类车子
        super.print();//父类车子
    }
}

package com.codesing;
//java中所有的类，都默认或间接或直接继承Object
public class Car /*extends Object*/{

    public Car(){
        System.out.println("Car无参构造");
    }

}

public class Falali extends Car {
    String name;
    public Falali(){//子类构造器和父类构造器不能同时调用
        //隐藏调用父类构造器 super();
        super();//调用父类构造器必须在子类构造器第一行。
                //调用子类构造器也必须在第一行。
        this("法拉利");//Call to 'this()' must be first statement in constructor body
        System.out.println("Falali无参构造");
    }
    public Falali(String name){
        this.name = name;
    }
}
//主方法
 Falali falali = new Falali();
    //Car无参构造-------》子类构造器隐藏调用super()
    //Falali无参构造

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M26Kx8Vw-1615202142054)(C:\Users\23236\AppData\Roaming\Typora\typora-user-images\image-20200917204436157.png)]

父类有参构造，子类无参写不了。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JPZUYNOP-1615202142057)(C:\Users\23236\AppData\Roaming\Typora\typora-user-images\image-20200917204735270.png)]

父类有参构造，子类想无参，必调父类有参构造。

5. 重写

1.前提：需要有继承关系，子类重写父类的方法

  1. 方法名必须相同
  2. 参数列表必须相同
  3. 都是方法重写，与属性无关
  4. 修饰符：范围可以扩大，public>protected>default>private
  5. 抛出异常：范围，可以被缩小，但不能被扩大：ClassNotfoundException–>Exception(大)

2.重写:子类的方法和父类必须一致：方法体不同！

3.为什么重写：

​ 父类功能，子类不一定需要，或者不一定满足

​ 快捷键：alt+insert：override

/*
静态方法： 方法调用只和左边，定义的数据类型有关
非静态方法：才叫重写
只能重写父类public() 或protected()方法
*/

package com.codesing;
//父类B
public class B {
    public static void test(){
        System.out.println("B=>test");
    }
}
//子类A
public class A extends B {

    public static void test(){
        System.out.println("A=>test");
    }
}
//
public class Application {
    public static void main(String[] args) {
        //方法调用只和左边，定义的数据类型有关
        A a = new A();
        a.test();  //A=>test
        //父类的引用指向子类
        B b = new A();
        b.test();  //B=>test
    }
}


package com.codesing;
//
public class B {
    public  void test(){
        System.out.println("B=>test");
    }
}
//加上注解@Override
public class A extends B {
    @Override//注解，重写
    public void test() {
        System.out.println("A=>test");
    }
}
//去点static后
public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();//A=>test
        
        //父类的引用指向子类
        B b = new A();//子类重写父类方法
        b.test();//A=>test
    }
}

6.多态

1.注意事项

​ .多态是方法的多态，属性没有多态

​ .父类和子类，有联系，类型转换异常ClassCastException

​ .存在条件：继承关系，方法需要重写。父类引用指向子类对象！Father f1 = new Son();

2.不能重写

. static 方法，属于类，不属于实例

. final 常量

. private 方法：

package com.codesing;

//java中所有的类，都默认或间接或直接继承Object
public class Car {

    public void run(){
        System.out.println("Car is run.......");
    }
}
//子类
public class Falali extends Car {
    @Override
    public void run() {
        System.out.println("Falali is run...");
    }
    public void say(){
        System.out.println("Falali is say...");
    }
}

//子类重写父类方法，则调用子类的。
public class Application {
    public static void main(String[] args) {

        //一个对象实际类型确定的
        //new Car()
        //new Falali()

        //可以指向的引用类型不确定,父类引用指向子类
        //Car：父类型，可以指向子类，但不能调用子类独存方法
        Car falali_0 = new Falali();
        //Falali：能调用自己的，和父类falali_0的方法
        Falali falali_1 = new Falali();
        Object falali_2 = new Falali();

        falali_1.run(); //Falali is run..
        falali_0.run(); //子类重写父类方法 Falali is run..

        //对象能执行哪些方法，主要看左边类型，右边没关系
        falali_1.say();//Falali is say...
        //falali_0.say();//报错，只能强转
        ((Falali) falali_0).say();//Falali is say...
    }
}


/*
 *    
 *     多态的成员特点:
 *         成员变量  编译时看的是左边，运行时看的左边
 *         成员方法  编译时看的是左边，运行时看右边
 *         静态方法  编译时看的是左边，运行时看的也是左边
 * 
 * 
 * 编译时看的都是左边，运行时成员方法看的是右边，其他（成员变量和静态的方法）看的都是左边
 * 
 */
public class PoymorphicDemo2 {
    public static void main(String[] args) {
        Dad d = new Kid();
        //System.out.println(d.num);
        
        //d.method();
        d.function();//使用变量去调用静态方法，其实相当于用变量类型的类名去调用
    }
}
 
class Dad {
    int num = 20;
    
    public void method() {
        System.out.println("我是父类方法");
    }
    
    public static void function() {
        System.out.println("我是父类静态方法");
    }
}
 
class Kid extends Dad {
    int num = 10;
    
    public void method() {
        System.out.println("我是子类方法");
    }
    
    public static void function() {
        System.out.println("我是子类静态方法");
    }
}

7.instanceof和类型转换

  1. instanceof(类型转换) 引用类型，判断一个对象是什么类型
  2. instaceof 判断两个类之间是否存在父子关系。有ture,无false
// 公式：System.out.println(x instanceof y) ------>看x指向的实际类型跟y是否存在父子关系

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



//类型之间的转换：父 <--->子
//子类转换为父类，可能会丢失自己的一些方法
Person person = new Student();//低-->高
((Student) person).eat();//高-->低:强转

Student student = new Student();//低-->高
student.eat();
Person person1 = student;//子类转父类
((Student) person1).eat();//这时丢失了自己eat()方法，只能强转
}

stem.out.println(person instanceof Person);//true
System.out.println(person instanceof Teacher);//false
//System.out.println(person instanceof String);//编译报错
System.out.println("=== ====== =========== ====");


```java
//类型之间的转换：父 <--->子
//子类转换为父类，可能会丢失自己的一些方法
Person person = new Student();//低-->高
((Student) person).eat();//高-->低:强转

Student student = new Student();//低-->高
student.eat();
Person person1 = student;//子类转父类
((Student) person1).eat();//这时丢失了自己eat()方法，只能强转
}
jzq_csdn_blog
关注
第1关：封装、继承和多态进阶（一）
d_k_dzy的博客
11-13 1151
声明一个带有两个参数的构造函数，声明抽象方法。，声明带有三个参数的构造函数，复写。，声明带有三个参数的构造函数，复写。编写测试类，通过有参构造函数实例化。通过有参构造函数实例化。具体输出要求请看测试说明。根据提示，在右侧编辑器。
pybind11学习 | 面向对象编程
MSTIFIY的博客
12-22 1680
pybind11学习 | 面向对象编程
定义一个Person类，含有姓名 (String类型，名name) 、性别 (String类型，名gender)、年龄(类型int，age) 等属性 定义无参构造器，每次无参构造器被调用会在控制台打印”创建一个人。 定义有参构造器，构造器有String类型
weixin_35752122的博客
12-19 1948
这是一个示例代码： public class Person { // 姓名 private String name; // 性别 private String gender; // 年龄 private int age; // 无参构造器 public Person() { System.out.println("创建一个人"); } // 有参...
Java杂学
彼岸花苏陌的博客
05-03 364
1.无参与有参构造 构造器在新建类会默认一个无参构造 例如 public class Student{ } 那么里面就会藏着一个 public class Student{ public Student(){ //不能用void 而且和构造名必须和类名一致 } } 有参构造 public class Pet{ String name; //定义name类型 public Pet(String name){ this.name=name;
java中public class Test｛ public Test(){ } ｝（Test()是类Test的构造方法）
热门推荐
qq_38188762的博客
11-15 1万+
public class testController implements Runnable { private String name; public testController(String name) { this.name=name; System.out.println("name:"+name); } public...
# Day01-Java基础
Java厂长
07-25 8045
Day01-Java 1、Java主要特点 简单性、跨平台性、分布性、安全性、健壮性、平台独立与可移植性、多线程、动态性、面向对象的编程语言、支持垃圾自动收集处理等，可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用等多个系统中。 2、计算机的高级汇编语言类型： 编译型——c语言 解释型——html 编译型和解释型的结合——java java运行原理源程序进行编译形成字节码文件在一台电脑进行解释程序 java最核心的部分就是虚拟机JVM 3、JVM（Java Visual Machine)
# Day09-Java基础
Java厂长
08-07 4892
Day09-Java 文章目录Day09-Java1、匿名内部类2、Object类简介2.1 取得对象信息toString()2.2 对象的比较equals()2.3 Object接口引用数据类型3、包装类3.1 装箱与拆箱3.2 字符串与基本数据类型的转换3.3 包的定义3.4 包的导入4、访问控制权限5、jar命令 1、匿名内部类 内部类：在一个类的内部定义了另外的类，称为内部类，匿名内部类指的是没有名字的内部类。为了清楚内部类的主要作用，下面首先观察一个代码。 interface IMessage{
# Day03-Java基础
Java厂长
07-27 7070
Day03-Java 1、private实现封装处理 如果像想要知道封装，首先必须清楚如果没有封装会怎么样？ 没有封装方法中的属性，在所有方法被调用后都可以进行无权限的访问。而当进行了封装操作之后，在实例化对象访问该方法的时候会出现无法访问的问题。 TestDemo1.java:11: 错误: name 在 Person 中是 private 访问控制 per.name = "张三"; ^ TestDemo1.java:12: 错误: a
Java-day08面向对象
dayu
01-30 966
day07-面向对象 java
06-11
day07-面向对象 java
GJXAIOU#Notes#JavaDay10-面向对象2.0 构造方法和this关键字1
07-25
一、开发工具 Eclipse 二、面向对象 之 构造方法 三、构造代码块 四、this 关键字 五、重载
Day03-Java面向对象.md
06-27
Java自学
day01-Java基础语法.zip
03-11
Java是一种广泛使用的面向对象的编程语言，以其跨平台、高性能和强大的库支持而闻名。"day01-Java基础语法.zip"很可能是一个教学资源包，用于介绍Java编程的基础概念和语法。下面我们将深入探讨Java的基础语法，包括...
day02-Java基础语法.pdf
12-13
Java 中的数据输入是通过 Scanner 对象来实现的。Scanner 对象可以从控制台读取用户输入的数据，并将其转换为相应的数据类型。 三、流程控制语句 流程控制语句是 Java 中用于控制程序执行流程的语句，包括顺序结构...
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 69
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java Stream流编程入门
2301_77207909的博客
09-21 464
Java StreamAPI的使用与常用方法
智能BI平台项目
2302_79400545的博客
09-22 200
BI商业智能：数据可视化、报表可视化系统。
JDK17新增语法特性
2201_76124988的博客
09-20 807
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 585
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值