Javase_1.2面向对象

最新推荐文章于 2024-07-13 03:12:45 发布
最新推荐文章于 2024-07-13 03:12:45 发布
阅读量165 收藏
点赞数
分类专栏： JUC和SE 文章标签： java 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25176263/article/details/112604465
版权

JavaSE 1.2 面向对象：

三大特征：封装，继承，多态。 四、抽象


对象和类（是一组相关属性和行为的集合）：

类一般是抽象的；对象是具体的。

一般情况下，类不能直接使用，需要根据类创建new一个对象到堆，才能使用。

导入包来使用包内类

import 包名称.类名称;

如果和当前的类属于同一个类可以不导。

对象的创建：

​ 类名称 对象名 = new 类名称();

使用：对象名加点

  1. 成员变量直接定义在类当中，在方法外。
  2. 成员方法没有static关键字。
//这是一个类
public class People{
	String name;
    int age;
    
    public void eat(){
    	System.out.println("吃饭")；   
    }
    
    public void sleep(){
        System.out.println("睡觉")；
    }
}

//创建对象
public class Test{
	public static void main(String[] args){
		People apeople = new People();
		apeople.eat();
		apeople.name;
	}
}

步骤在JVM内存中：

main方法进栈之后。通过方法区保存的klass，在堆中创建一个对象，将对象的引用赋值给变量。

类方法保存在方法区（Method area）中 ，堆中有指向方法区的地址。这个地址保存在堆中与变量一起保存在同一个地址。成员变量在堆（heap）中找到，方法通过堆中的地址在方法区中找到方法。


对象的使用：

对象作为方法传入参数，传入的是对象的名字即地址。

对象作为方法的返回值，返回的也是对象的地址值。


匿名对象：

在确定只使用一次的时候就可以new后直接使用，创建后无法再次找到。

public static void main(String[] args) {
    System.out.println("result:" + new Scanner(System.in).nextInt());;
}
匿名对象作为参数或者返回值：此时匿名函数就能被找到了
public static void main(String[] args) {
        likeThis(new Scanner(System.in));
        System.out.println(likeThat().nextInt());
    }

    public static void likeThis(Scanner sc){
        System.out.println(sc.nextInt());
    }

    public static Scanner likeThat() {
        return new Scanner(System.in);
    }

内部类：

  1. 外部类：public / (default)
  2. 成员内部类：public / protected / (default) / private
  3. 局部内部类（方法内部类）：什么都不能写
  4. 静态内部类
  5. 匿名内部类
成员内部类 ：

定义在类中方法外的类。

​ 在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，汽车类 Car 中包含发动机类 Engine ，这时， Engine 就可以使用内部类来描述，定义在成员位置。

内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，前面冠以外部类的类名和$符号 。

// 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
Outer.Inner obj = new Outer().new Inner();
obj.methodInner();
匿名内部类【重点】

​ 是内部类的简化写法。它的本质是一个带具体实现的、父类或者父接口的、匿名的、子类对象。
​ 必须继承一个父类或者实现一个父接口。
​ 以接口举例，当你使用一个接口时：

  1. 定义子类
  2. 重写接口中的方法
  3. 创建子类对象
  4. 调用重写后的方法

我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。

创建格式

new 父类名或者接口名(){ 
    // 方法重写 
    @Override 
    public void method() { 
        // 执行语句
    } 
};//这里由于是实例而不是类，末尾有分号

​ （Anonymous classes enable you to make your code more concise. They enable you to declare and instantiate a class at the same time. They are like local classes except that they do not have a name. Use them if you need to use a local class only once.）

​ 匿名内部类可以使你的代码更加简洁，你可以在定义一个类的同时对其进行实例化。它与局部类很相似，不同的是它没有类名，如果某个局部类你只需要用一次，那么你就可以使用匿名内部类

官方例子：
public class HelloWorldAnonymousClasses {

    /**
     * 包含两个方法的HelloWorld接口
     */
    interface HelloWorld {
        public void greet();
        public void greetSomeone(String someone);
    }

    public void sayHello() {

        // 1、局部类EnglishGreeting实现了HelloWorld接口
        class EnglishGreeting implements HelloWorld {
            String name = "world";
            public void greet() {
                greetSomeone("world");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hello " + name);
            }
        }

        HelloWorld englishGreeting = new EnglishGreeting();

        // 2、匿名类实现HelloWorld接口
        HelloWorld frenchGreeting = new HelloWorld() {
            String name = "tout le monde";
            public void greet() {
                greetSomeone("tout le monde");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Salut " + name);
            }
        };

        // 3、匿名类实现HelloWorld接口
        HelloWorld spanishGreeting = new HelloWorld() {
            String name = "mundo";
            public void greet() {
                greetSomeone("mundo");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hola, " + name);
            }
        };

        englishGreeting.greet();
        frenchGreeting.greetSomeone("Fred");
        spanishGreeting.greet();
    }

    public static void main(String... args) {
        HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses();
        myApp.sayHello();
    }
}

// 如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名

  1. 匿名内部类，在【创建对象】的时候，只能使用唯一一次。
    如果希望多次创建对象，而且类的内容一样的话，那么就需要使用单独定义的实现类了。
  2. 匿名对象，在【调用方法】的时候，只能调用唯一一次。
    如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
  3. 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
    强调：匿名内部类和匿名对象不是一回事！！！

局部内部类：

出了这个方法外面就不能用了。
如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】。
从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。
原因：生命周期问题

  1. new出来的对象在堆内存当中。
  2. 局部变量是跟着方法走的，在栈内存当中。
  3. 方法运行结束之后，立刻出栈，局部变量就会立刻消失。
  4. 但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。

其他类对内部类的调用

JVM编译时也会生成独立的class文件，名称为外部类名$内部类名

其他类调用该内部类，

静态内部类：

OuterClass.InnerClass().staticMethod();
new OuterClass.InnerClass().Method();

非静态内部类：

OuterClass ot = new OuterClass();
InnerClass ic = ot.new InnerClass();

封装：

高内聚，低耦合

单一特定的功能，

使用接口降低耦合度。

private ：

可以用于控制成员变量的访问，成员变量就不能在类外被访问了，通过访问类内控制该private变量的方法来改变。从而限制把关该成员变量。用setter/getter方法，命名规则如下：

public class Person{
    String name;//可在类外访问，Person.name。
    private int age;//出了该类无法访问。
    
    public void setAge(int num){//不能有返回值，参数类型与成员变量对应。setXxxx。
        if(num < 100 && num >= 5){//可以加把关的方法。
        	age = num;
        }else{
            sout"数据不合理"
        }
    }
    
    public int getAge(){//不能有参数，返回值类型（return和方法名前两处）与成员变量对应。getXxxx，Boolean时为isXxxx。
        return age;
    }
}
this：

this指向当前对象自己 。

当成员变量名（即方法外定义的变量）与方法的局部变量相同时，该方法内就近原则，优先使用局部变量（一般是传入的参数）。

可以解决重名问题。

通过谁调用的，谁就是this。this与类名相等（都代表同一个地址）

public class Person{
    String name；
        public void method(String name){
        sout name+"你好，我是"+ this.name //this就是该类的成员变量
    }
}

构造：

  • 游离块在构造方法之前执行。
  • 专门用来创建对象的方法，通过new创建对象时，就是在构造方法。
  • 即 Person zly = new Person();//这里的Person()即是调用构造方法。
  • 构造方法的名称必须和所在类的名称完全一样，包括大小写。
  • 构造方法没有返回值类型，没有return返回值。
  • 如果没有编写构造方法，那么编译器会默认一个空的构造方法。
  • 编写至少一个构造方法，默认的构造方法就不会生成。
  • 构造方法可以重载。

继承性：

继承是多态的前提，如果没有继承就没有多态

继承

定义父类的格式：public class，与普通类没有区别，子类：extends 父类名称。

public class Employee{}//正常
public class Teacher extends Employee{}//新建类

重名：
成员变量重名：

直接通过子类对象访问，等号左边是谁，就优先用谁，没有则向上找。

间接通过成员方法访问成员变量：

该方法属于（定义）谁优先用谁，没有向上找。Zi.findNumFu()，子类调用继承的父类方法用到的是父类的同名变量

子类方法中三种重名：
	System.out.println(num); // 30，局部变量
	System.out.println(this.num); // 20，本类的成员变量
	System.out.println(super.num); // 10，父类的成员变量
方法重写override，或者叫复写，参数列表也一样：

调用父类同名方法。

1.在重写前加@override，@表示annotation，注解，可以帮助检测是否正确重写，看是否报错，可以不写。

2.与重载相比，重写的参数列表要相同，且子类方法的返回值必须小于等与父类方法的返回值范围。

3.子类方法的权限必须大于等于父类方法权限：

​ public > protected > (default) > private default表示留空，不写

父子类构造特点：

先执行父类构造，后子类构造，子类必有父类构造方法，父类无参则子类默认隐含 super();，如果父类只定义有参构造是无法进行默认super调用的，得手动补全有参super。

public Zi(){
    //super(); //调用父类无参构造方法，有参则使用super(type parameter);重载构造方法。
}

super的父类构造调用，必须是子类构造方法的第一个语句，且一个子类构造只能调用一次super构造。

super：

在子类成员方法中调用父类成员变量或者成员方法，点；在子类构造方法中访问父类构造方法

this：

在子类成员方法中调用本类成员变量或者成员方法，点；在子类构造方法中访问本类构造方法，this（）；必须是第一个语句，所以构造重载只能选一个，可以接龙。
在这里插入图片描述

继承特点：

**Java是单继承的：**一个类只能有一个直接的父类。

**Java可以多级继承的：**多级父类，最顶级就是java.lang,Object类。

Java子类不限一个父类可以有很多子类

设计原则：

对应已经投入使用的类，尽量不要修改，定义一个新的类来重复利用其中的共性内容。

public void show() {
	super.show(); // 把父类的show方法拿过来重复利用
	// 自己子类再来添加更多内容
	System.out.println("显示姓名");
	System.out.println("显示头像");
}

抽象方法：

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有 意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。

Java语法规定，包含抽象方法 的类就是抽象类。

声明方法，加上abstract，方法在返回值前加，且class之前也写上abstract，抽象方法所在的类必须是抽象类。

public abstract class something{
    public void normalMethod(){
    }
	public abstract void abstMethod();
}
注意事项

  1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
    理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

  2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
    理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

  3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
    理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设 计。

  4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象 类。
    理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有 意义。


接口：

idea new的时候选择interface，大驼峰。

一种公共的规范标准，只要符合就可以通用。很像抽象类，用来补充没有多继承的问题。
多个无关的类可以实现同一个接口，一个类可以实现多个无关的接口。
接口不是类，是一种引用类型，接口.java编译之后字节码文件也是.class。

public interface InterfaceName{
1.常量//JDK 7+
    public static final 数据类型 常量名称 = 数据值;
    //接口当中的常量，可以省略public static final，必须赋值，接口中没有成员变量
    //使用完全大写的字母，用下划线进行分隔。
    
2.抽象方法//JDK 7+ 
	public abstract void methodAbs();//public abstract是固定的省略的
    //
    
3.默认default方法//JDK 8+
    public default void method() { // 执行语句 }
    //接口当中的默认方法，可以解决接口升级的问题。me:实现类可以不用override了
    //接口的默认方法，可以重写，可以继承
    
4.静态方法//JDK 8+
    public static void method2() { // 执行语句 }
    //通过接口名称，直接调用其中的静态方法。
    
5.私有方法//JDK 9+，8好像也有
    private void method() { // 执行语句 }//是对默认和静态方法的辅助，用于提高代码复用
    //私有方法：只有默认方法可以调用。 
    //私有静态方法：默认方法和静态方法可以调用。
}
    //不能有静态代码块
    //没有构造方法，不能创建对象

接口的使用：

实现：
public class Name [DemoInterface extends FuClass] implements InterfaceName1,InterfaceName2{}//[]可选

而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。

抽象方法：

实现类必须覆盖重写接口中所有的抽象方法（Alt + Enter），然后创建实现类的对象进行使用。

实现类中多个接口有重名抽象方法则只需重写一次。

如果没有全部override抽象方法那么实现类得是抽象类。

默认方法：

如果实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。

一个类如果继承父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。

接口的多继承：//类与接口多实现，多接口，类与类单继承，接口与接口多继承

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继 承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次。

子接口重写默认方法时，default关键字可以保留。

子类重写默认方法时，default关键字不可以保留。


多态：

​ 重写式多态，也叫运行时多态。这种多态通过动态绑定（dynamic binding）技术来实现，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。也就是说，只有程序运行起来，你才知道调用的是哪个子类的方法。 这种多态通过函数的重写以及向上转型来实现，

是指同一行为，具有多个不同表现形式。

看new的是谁，就优先用谁，没有则向上找。

前提：
  1. 继承或者实现【二选一】
  2. 方法的重写【意义体现：不重写，无意义】
  3. 父类引用指向子类对象【格式体现】
格式：
父类名称 对象名 = new 子类名称();
或者：
接口名称 对象名 = new 实现类名称();
// 左侧父类的引用，指向了右侧子类的对象

成员变量：编译看左边，运行还看左边。
成员方法：编译看左边，运行看右边。

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写0后方法。

	Fu obj = new Zi(); // 多态
	obj.method(); // 父子都有，优先用子
	obj.methodFu(); // 子类没有，父类有，向上找到父类
	//obj.methodZi();
    //编译看左边，左边是Fu，Fu当中没有methodZi方法，所以编译报错。
引用类型的转换：

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转型。

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

子类类型 变量名 = (子类类型) 父类变量名; 
如:Cat c =(Cat) a;
向下转型的用途：

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。不能调用子类拥有，而父类没有的方法，这时就要向下转型。

转型异常：没有继承关系，可以用 instanceof 关键字

对象 instanceof 类名称 也就是一种类型

这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。

if (animal instanceof Dog) {
	Dog dog = (Dog) animal;
	dog.watchHouse();
}
if (animal instanceof Cat) {
	Cat cat = (Cat) animal;
	cat.catchMouse();
}
向下转型的用途：

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。不能调用子类拥有，而父类没有的方法，这时就要向下转型。

转型异常：没有继承关系，可以用 instanceof 关键字

对象 instanceof 类名称 也就是一种类型

这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。

if (animal instanceof Dog) {
	Dog dog = (Dog) animal;
	dog.watchHouse();
}
if (animal instanceof Cat) {
	Cat cat = (Cat) animal;
	cat.catchMouse();
}

java.lang.Object:

是所有类的公共最高父类。java.lang.String就是Object的子类。


标准类 Java Bean：

看框架

所有成员变量使用private关键字修饰

为每一个成员变量都编写一对Getter/Setter方法

编写一个无参构造和一个全参构造

idea 快捷键 ：Alt+Insert，或者Code中的Generate。Constructor，Getter and Setter。

boolean为isVariable

名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a;

leakyRelu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
父类赋值给子类
06-07
父类赋值给子类的一个小方法，仅供学习参考...
JAVASE基础_课堂笔记-V2.docx
03-28
- **面向对象**：Java是一种完全面向对象的语言，它通过封装、继承和多态来实现对象之间的交互。 - **简单易用**：相较于C++，Java简化了许多复杂概念，如自动垃圾回收机制，避免了内存泄漏等问题。 - **健壮性**：...
Java30天养成计划 || 08 面向对象特性——封装||继承||多态
冰冻三尺，非一日之寒
12-01 281
一篇带你入门Java精髓的博客，图文并茂，火速三连！
超全面的C++知识点概括
Li17_的博客
10-04 693
C++是对C的补充和扩充，C是C++的一个子集 C 面向过程 用函数解决问题 C++ 面向对象 用成员方法解决问题 C++在兼顾了C执行效率高的优点下提高了编程效率 C++之父——本贾尼.斯特劳斯特朗普 C++ 的文件后缀名可以是 .cpp .cxx .c++ .cc .C 编译C++程序 g++ 或 gcc -lstdc++ 1.名字空间 namespace (1)概念 C++对于变量、类型、函数在逻辑上的一个划分，一个名字空间相当于一个作用域 (2)使用 声明定义一个namespace name
父类对象的属性直接赋值给子类对象(使用copyProperties中的方法copyProperties）
Layman的博客
05-15 3479
这样就可以将一个 JavaBean 对象的属性值赋值到另一个 JavaBean 对象中，从而实现了属性复制的功能。需要注意的是，BeanUtils.copyProperties() 方法会将两个 JavaBean 对象中名称相同、类型相同、可读可写的属性进行映射赋值。BeanUtils.copyProperties() 是 Apache Commons BeanUtils 包中提供的一个方法，用于将一个 JavaBean 对象的属性值赋值到另一个 JavaBean 对象中。通常用于父类对象赋值个子类。
java 父类对象赋值给子类
yin__ren的博客
12-14 5462
方式一： private void fatherToChild(Object father, Object child) { if (!(child.getClass().getSuperclass() == father.getClass())) { try { throw new Exception(child + "不是" + father + "的子类"); ...
JavaSE之多态体系
07-21
JavaSE中的多态是面向对象编程的一个核心特性，它允许我们使用父类类型的引用操作子类对象，从而实现更灵活的代码设计。多态的概念简单来说就是“一个接口，多种形态”。这种特性使得程序在设计时能够保持抽象，提高...
面向对象技术与UML课件及源代码-by 南邮-陈杨
06-06
本书涵盖了JavaSE开发环境配置、程序设计基础、面向对象相关技术、常用API、UML基础知识。在章节中穿插了上机习题，并提供了答案，用于对该章内容进行阶段性总结演练。 作者长期从事教学工作，积累了丰富的经验，其...
javaSE代码实例
06-21
6.1.2　面向过程与面向对象思想的对比　78 6.1.3　面向对象技术的背景和特点　79 6.2　类的定义与对象的创建　80 6.3　成员变量　81 6.3.1　成员变量的开发与使用　81 6.3.2　成员变量的初始值　82 6.3.3　对象引用...
java 子类对象赋值给父类对象的使用
12-12
java 子类对象赋值给父类对象的使用，包括代码及详解，个人笔记
将父类的属性赋值给子类(利用反射)
blueangle17的专栏
09-29 2975
转自：https://blog.csdn.net/qq_36354669/article/details/79807994 public class A { private String a; private String b; public String getA() { return a; } public void setA(S...
把父类的属性值赋值给子类
qq_41988504的博客
03-25 3051
package com.tl.gateway.plugins.user.authentication.plugin.util; import java.lang.reflect.Field; import java.lang.reflect.Method; /** * @Author: lc * @Date: 2020/3/25 9:53 */ public class Subclas...
Java内部类同名成员变量的调用
Harris-H的博客
09-27 554
Java内部类同名成员变量的调用 package 内部类; public class Outer { int a = 30; //外部类的成员变量 public class Inner{ int a = 20; //内部类的成员变量 public void fun(){ int a = 10; //成员方法的局部变量 System.out.println(a); System.o
java父类对象的值如何给子类
最新发布
weixin_29615645的博客
07-13 54
如何将Java父类对象的值传递给子类 在Java编程中，经常会遇到将父类对象的值传递给子类的需求。这种情况下，我们需要使用一些特定的技巧来实现这个目标。本文将介绍如何在Java中实现这个功能，并提供一个具体的示例来说明。 实际问题 假设我们有一个父类Person，其中包含姓名和年龄两个属性。我们还有一个子类Student，...
java继承：父类对象可以被子类赋值，反之不行哦
小楼一夜听春雨
01-25 2669
直接看例子、注释和输出吧 class A { public void func1() { System.out.println("A func1 is calling"); } public void func2() { func1(); } } class B extends A { public void func1() { System.out.println("B func1 is calling");
java反射 父类所有值赋值给子类
wellcome 2 天明's 博客
09-08 631
public static <T>void fatherToChild(T father,T child) throws Exception { if (child.getClass().getSuperclass()!=father.getClass()){ throw new Exception("child 不是 father 的子类"); } Class<?> fatherClass = father.getC.
java循环属性父对象赋值给子对象
czh4869623的专栏
09-27 416
java循环属性父对象赋值给子对象
JavaSE基础教程：从入门到精通
这份JavaSE基础学习笔记涵盖了从Java技术基础到面向对象编程的全面内容，是初学者掌握Java编程语言的宝贵资料。 一、Java技术基础： 1.1 编程语言：讲解了编程语言的基本概念，以及编程语言在计算机科学中的作用。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值