java基础快速入门07

joker学java2025-03-30 16:01

面向对象编程

基本语法

typescript 复制代码 
package chapter04;

public class java_Object02 {
    public static void main(String[] args) {
        //TODO 面向对象  基本语法
        /*
        声明
           类的声明：class 类名{
            属性（0个或多个）
            数据类型名 变量名 = 值；
            方法（行为，0个或多个）
            void 方法名（参数）{ 方法代码 }

        使用
        对象构建：new 类名
        一般会构建一个变量 把对象赋给变量；
        属性访问：变量名.属性；
        方法访问：变量名.方法；

         }
         */
    }
}
csharp 复制代码 
package chapter04;

public class java_Flowconcle {
    public static void main(String[] args) {
        //TODO 面向对象
        //所谓面向对象就是以问题所涉及的事和物为中心；
        //类和对象
        //类表示归纳和整理；（类里面有）
        //对象表示具体的事物；
        //TODO class（类）
        /*
        类的基本语法
        class 类名{//类的名称规范上首字母是要大写；
            特征（属性）
            功能（方法）
        }

         */
        //创建对象的基本语法结构
        // new 类名();

        //问题做一道菜？红烧排骨
        //；类：菜  对象：红烧排骨
        //TODO 1 声明类
        //TODO 2 创建对象
        //TODO 3 声明属性
//               变量类型  变量名 = 变量值；
//               属性类型  属性名 = 属性值；
        //       属性使用  对象名.属性 = 属性值；

        //TODO 4 声明方法
        //       void 方法名(参数){ 方法代码； }
        //TODO 5 执行方法
        //       对象名.方法名(参数（可不填）);
        Cooking c =new Cooking();
        c.name = "红烧排骨";
        c.sicai = "排骨";
        c.zuoliao = "花生";
        c.cl();
        Cooking yu = new Cooking();
        yu.name = "红烧鱼";
        yu.sicai = "鱼";
        yu.cl();
    }
}
class Cooking{

    //特征（属性）；
    String name;

    String sicai;

    String zuoliao = "大麻";
    //功能（方法）
    void cl (){
        System.out.println("准备食材" + sicai);
        System.out.println("准备佐料" + zuoliao);
        System.out.println("准备烹制" + name);
        System.out.println(name + "烹制完成");

    }
}

当对变量c做处理时并不是对变量做处理而是对变量c所指向的Cooking做处理；

案例分析

typescript 复制代码 
package chapter04;

public class java_Flowconcle01 {
    public static void main(String[] args) {
        //类：学生，老师
        //对象：李四，张三，赵五；
        Techer t1 = new Techer();
        Student s1 = new Student();
        Student s2 = new Student();
        t1.name = "李四";
        s1.name = "张三";
        s2.name = "赵五";
        t1.tech();
        s1.play();
        s2.study();
    }
}
class Techer{
    String name;
    void tech(){
        System.out.println("老师" + name + "在教课");
    }
}
class Student{
    String name;
    void study(){
        System.out.println("学生" + name + "在学习");
    }
    void play(){
        System.out.println("学生" + name + "在打游戏");
    }
}
  • 栈里面的变量指向堆；栈的变量==堆地址；
  • 基本数据类型直接存在栈中
  • 引用数据类型中变量指向某个地方；

类和对象

基本语法

typescript 复制代码 
package chapter04;

public class java_Object02 {
    public static void main(String[] args) {
        //TODO 面向对象  基本语法
        /*
        声明
           类的声明：class 类名{
            属性（0个或多个）
            数据类型名 变量名 = 值；
            方法（行为，0个或多个）
            void 方法名（参数）{ 方法代码 }

        使用
        对象构建：new 类名
        一般会构建一个变量 把对象赋给变量；
        属性访问：变量名.属性；
        方法访问：变量名.方法；

         }
         */
    }
}

详细介绍

typescript 复制代码 
package chapter04;

public class java_Object03 {
    public static void main(String[] args) {
        //TODO 面向对象；
        /*
        //类是一种结构体，他包含了属性（特征）和方法（行为）
          有许多对象；
        class 是关键字（关键字全是小写）
        类名 是一种标识符（和变量名一样）；首字母要大写；

        //对象是类的具象化（实例化）
        new 类名();
        new 也是一个关键字，每次使用都会创建一个对象；每次都是全新的一个对象
        一般new出来的对象都会赋给一个变量（为了方便后续操作）；
        变量的数据类型就是对象的类型；
        对象将内存地址赋给了变量；变量是引用了一个内存地址；
        类名 变量名 = new 类名();

        空对象
        User use = null；
         */
    }
}

属性

typescript 复制代码 
package chapter04;

public class java_Object04 {
    public static void main(String[] args) {
        //TODO 面向对象----属性；

        //所谓属性就是类对象的相同特征；
        //属性语法和变量很相似；
        //如果声明属性是进行了初始化；那么每个对象的这个属性都相同；
        //如果不希望每个属性相同就不进行初始化；
        //属性会在定义时默认初始化，
        //会根据不同的类型进行不同的初始化赋值；
        /*
        byte，short,int,long==0;
        float,double==0;
        boolean==false;
        char =空；
        引用类型==null；
         */


        //属性和变量的区别；
        //变量的作用域仅在当前大括号有用；
        //属性的作用域只要有对象的声明那么在本个大括号便有用；
        //变量必须声明，赋值才能直接使用；属性可以声明后直接使用；他有默认初始值；


    }
}

class User{
    //String name = "liuyu";
    String name;

}

方法

csharp 复制代码 
package chapter04;

public class java_Object05 {
    public static void main(String[] args) {
        //TODO 面向对象---方法
        //声明语法 void 方法名 (){ 方法代码 }；
        //声明补充 {返回值类型}/{void} 方法名(){ 方法代码 }
        //void 是指不返回结果；

        //调用语法 对象名.方法名();

        //实现用户账号和密码的注册和登录；
        //名词：用户，账号，密码；找类和属性
        //类：用户；属性：账号，密码；
        //动词：注册，登录；找方法；
        //先注册成功再登录；
        User05 user = new User05();

        boolean registerResult = user.register();
        if( registerResult ) {
            System.out.println("注册成功");
            boolean loginResult = user.login();
            if( loginResult ){
                System.out.println("登录成功");
            } else {
                System.out.println("登录失败");
            }


        } else {
            System.out.println("注册失败");
        }
    }
}
class User05{
    //属性
    String account;
    String password;
    //方法

    boolean register (){
        System.out.println("用户注册");
        return true;
    }
    boolean login(){
        System.out.println("用户登录");
        return false;
    }

}

方法参数

arduino 复制代码 
package chapter04;

public class java_Object006 {
    public static void main(String[] args) {
        //TODO 面向对象------方法参数
        //使用外部的数据控制方法内部实现的操作，使用的是方法参数；
        //基本声明语法：  void 方法名 ( 参数类型 参数名 ){ 方法代码 }；
        //基本使用语法：  对象名.方法名( 参数类型 参数名 )；

        //多个参数 void 方法名 ( 参数类型1 参数名1 , 参数类型2 参数名2 ){ 方法代码 }
        //使用语法  对象名.方法名( 参数类型1 参数名1 ， 参数类型2 参数名2 )；
        //1 参数个数匹配；
        //2 参数类型匹配；
        //3 参数顺序匹配；

        //4 当参数个数不确定时，类型一样，可以采用 可变参数
        //声明语法 void 方法名 (参数类型...参数名称)；
        //调用 对象名.方法名(名1，名2，....);
        User006 user = new User006();
        user.Printname("liuyu","lisi");
    }
}
class User006 {

    void Printname (String... name){
        System.out.println(""+name);
    }

}

参数传递；

  1. 在基本数据类型中，java传值只是传了一个表面值；
  2. 在引用数据类型中，java传值是传来一个地址因为引用数据类型它的变量值本身就是一个指针

示例

一.基本数据类型

csharp 复制代码 
package chapter04;

public class java_Object07 {
    public static void main(String[] args) {
        int i = 10;
        jia(i);
        System.out.println(i);
    }

    public static void jia(int i){
        i = i + 10;
        System.out.println(i);
    }
}

压栈； 弹栈；但是方法jia中的i的数值并未被修改，因为方法jia直接被弹走了； 二.字符串

typescript 复制代码 
package chapter04;

public class java_Object07 {
    public static void main(String[] args) {
        String i = "abc";
        jia(i);
        System.out.println(i);
    }

    public static void jia(String i){
        i = i + 10;
        System.out.println(i);
    }
}

很多人可能以为结果为abc10,abc10;但是真的如此吗？

结果却完全不是这样；

Why？？？

因为在jia方法中i = i + 10；会产生一个新的字符串；他有一个新的地址；并不是在原来main 中i的地址进行修改； 三.对象

ini 复制代码 
package chapter04;

public class java_Object07 {
    public static void main(String[] args) {
        User07 user = new User07();
        user.name = "liuyu";
        user.age = 8;
        System.out.println(user.name + user.age);
        jia(user);

        System.out.println(user.name + user.age);
    }

    public static void jia(User07 user){
       user.age += 10;
       user.name = "刘宇来了";
    }
}
class User07{
    String name;
    int age;
}

！image.png

方法jia中的数值修改直接修改到了堆中对象的值，即使弹栈后main中的user.name和user.age 也已经被修改；（对象起到了一个指针的作用）

静态

java 复制代码 
package chapter04;

public class java_Object08 {
    public static void main(String[] args) {
        //针对于具体对象的属性称之为对象属性，成员属性，实例属性；//必须先创立一个对象才能使用；
        //针对于具体对象的方法称之为对象方法，成员方法，实例方法；
        //把和对象无关只和类有关的称之为静态；
        //和类相关的属性成为静态属性；//可以不用创建对象直接用类使用；
        //和类相关的方法成为静态方法；
        Bird xiaoniao = new Bird();
        System.out.println(Bird.type);
        Bird.fly();

        Chinese c = new Chinese();
        c.name = "liuyu";
        System.out.println("Hello," + c.name + c.nationaltiny);
    }
}
class Bird{
    static void fly (){
        System.out.println("飞>>>>");
    }
    static String type = "鸟";
}

class Chinese{
    String name;

    String nationaltiny = "中国";

}
csharp 复制代码 
package chapter04;

public class java_Object09 {
    public static void main(String[] args) {
        //TODO 面向对象---静态---静态代码块
        //先有类，再创建对象
        //可以创建对象去访问静态属性和静态方法
        //成员方法可以访问静态属性和静态方法；
        //静态方法不可以访问成员属性和成员方法；
        User09 user = new User09();
        user.name = "liuyu";
        user.Jia();
       // User09.jia();
    }
}
class User09{
    static int age;
    String name;
    static void jia () {
        System.out.println("加");
        System.out.println(name);
    }
    void Jia (){
        System.out.println(age);
        jia();
    }

}
csharp 复制代码 
package chapter04;

public class java_Object10 {
    public static void main(String[] args) {
       //new User10();
        //类的信息加载完成后会自动调用静态代码块；先
        //对象准备创建时会调用代码块，但不是静态的；后
        new User10();
        User10.text();
    }

}
class User10{
    static{//静态代码块
        System.out.println("静态代码块1");
    }
    static {
        System.out.println("静态代码块2");
    }
    {
        System.out.println("hihihi1");
    }
    static void text() {
        System.out.println("六百六十六");
    }
    static {
        System.out.println("静态代码块3");
    }
    {
        System.out.println("hihihi2");
    }
}

包

typescript 复制代码 
package chapter04.textPackage;

public class java_Object001 {
    public static void main(String[] args) {
        //TODO 面向对象------包；
        //package 容纳类；
        //主要语法package 包的完整路径；
        //路径中多个包使用.隔开；
        //包的主要作用是分类管理；


        //一个类可以没有包，但是不能有多个package；
        //包名要小写，目的是为了给类进行区分；
        //javax.xml.crypto.Data

        //java中存在相同名称的类但位于不同名称的包里面；
        //我们可以依靠包来进行区分；
        //java.util.Date;

    }
}

import

java 复制代码 
package chapter04;
import javax.xml.crypto.Data;
import java.util.*;

public class java_Object11 {
    public static void main(String[] args) {
        //TODO 面向对象--- import
        //import 主要用于在类使用之前就已经准备好了
        //import 写在包后，第一个class前
        //import 可以多次导入使用多个类；
        //如果同一个包里需要导入多个类可以用通配符*；来简化操作；
        //如果import了不同包中相同名的类，需要使用时加上包名

        //如果应用的类在同一个包中，那么不需要import
        //import long包里的类不需要import，因为用的太多了所以JavaJvm在使用时会自动补充；
        //比如字符串，数组；
        java.util.Date d = new java.util.Date();
        System.out.println(d);

    }
}

构建方法

csharp 复制代码 
package chapter04;

public class java_Object12 {
    public static void main(String[] args) {
        //TODO 面向对象 - 构建对象；
        //如果一个类中没有任何构造方法，那么JVM会提供一个公共的，无参的构造方法，方便对象的调用；
        //TODO 基本语法：类名(参数){ 代码块 };
        // 1 构造方法也是方法，与方法不同的是没有关键字void；
        // 2 方法名和类名完全相同；
        // 3 如果类中没有构造方法那么JVM会提供默认的方法；
        // 4 如果类中有构造方法那么JVM不会提供默认的方法；
        // 5 构造方法也是方法也可以传递参数，一般用于对象的初始化赋值；

        User12 user = new User12("liuyu");

       System.out.println(user.username);
    }
}

class User12 {
    {
        System.out.println("代码块1");
    }
    String username ;
    User12(String name) {
        username = name;
        System.out.println("...");
    }
    {
        System.out.println("代码块2");
    }

}

继承

scala 复制代码 
package chapter04;

public class java_13Object {
    public static void main(String[] args) {
        //TODO 面向对象 - extends - 继承
        //面向对象最重要3个特征的继承，封装，多态；
        //类存在父子关系，子类可以直接从父类里面继承父类的属性和方法；//包括构造方法；
        //一个子类只能对应一个父类；一个父类可以对应多个子类；

        //继承采用extends语法 子类 extends 父类
        Child c1 = new Child();
        System.out.println(c1.name);
        c1.Text();
    }
}

class Partent{
    String name = "liuyu";
    Partent(){
        System.out.println("Partent");
    }
    void Text () {
        System.out.println("text");
    }
}
class Child extends Partent{

}

对象和构造方法；

scala 复制代码 
package chapter04;

public class java_Object15 {
    public static void main(String[] args) {
        //父类对象是在子类对象创建前创建的，会调用父类的创建方法；
        //默认情况下，子类对象构建时会默认调用父类的构建方法完成父类对象的构建，采用的是super关键字，只不过是JVM自动完成；
        //如果父类有构造方法那么JVM不会提供默认的构造方法，子类应该显示super的方式来构建父类对象；

        new Child15();
        new Child15();
        new Child15();
        //new：只会构建一个对象，所以说只会构建一个子类对象，并且在子类对象中开辟了一块内存用来存储父类对象以及方法；
    }
}
class Partent15{
    String username;
    Partent15 ( String name ){
        username = name;
        System.out.println("Partent15>>>");
    }
}
class Child15 extends Partent15{
    Child15(){
        super("liuyu");
        System.out.println("Child>>>");
    }
}

多态

scala 复制代码 
package chapter04;

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

        //所谓多态就是一个对想在不同场景下表现出不同的状态和形态
        //多态的语法其实就是对想进行了约束；
        //一个对象所使用的功能取决于他所引用的变量类型；
        Person p1 = new Person();
        Person p2 = new Boy();
        //p2.text();
        Person p3 = new Girl();
        //p3.text();
        Boy boy = new Boy();
        boy.text();
        Girl girl = new Girl();
        girl.text();
    }
}
class Person{
    Person () {
        System.out.println("person test>>>");
    }
}
class Boy extends Person {
    void text() {
        System.out.println("BOY text...");
    }
}
class Girl extends Person{
    void text(){
        System.out.println("Girl text...");
    }
}

方法重载

typescript 复制代码 
package chapter04;

public class java_Object17 {
    public static void main(String[] args) {
        //一个类中不能重复声明名称相同的属性和方法
        //这里的相同方法是指方法名和参数列表相同，与返回值无关；
        //如果方法名相同但是参数（个数，顺序，类型）不相同，那么虽然是相同的方法名但却是不同的方法；
        //这个操作称之为方法的重载
        //构造方法也存在方法的重载；

        User17 user = new User17();
        User17 user1 = new User17("liuyu");
        user.login("liuyu" , 123);
        user.login(123);
        user.login("wx");

    }
}
class User17{
    User17(){
        System.out.println("user...");
    }
    User17( String name ) {
        System.out.println("user" + name);
    }

    void login( String account , int password ){
        System.out.println("账号，密码登录");
    }
    void login( int tell ){
        System.out.println("手机验证码登录");
    }
    void login( String wx  ){
        System.out.println("微信，支付宝登录");
    }


}

方法重载小练习

kotlin 复制代码 
package chapter04;

public class java_Object18 {
    public static void main(String[] args) {
        //如果在一个类中一个构造方法调用另一个构造方法需要用到this；
        //
        new User18();
//        new User18("liuyu");
//        new User18("liuyu" , "男");
    }

}
class User18{
    User18(){
        this("liuyu");
    }
    User18( String name ){
        this(name , "男");
        System.out.println(name + " ");
    }
    User18( String name, String sex ){
        System.out.println( name + "," + sex);
    }
}
arduino 复制代码 
package chapter04;

public class java_18Object_1 {
    public static void main(String[] args) {
        byte b = 10;
//        text(b);

        //byte==>8
        //short==>16
        //char==>16
        //int==>32
        //基本数据类型在匹配方法是如果没找到对应的数据类型则会扩大数据精度；
        //byte类型无法转化成char类型；因为char是字符类型没有负数；



    }
//    static void text( byte b ){
//        System.out.println("bbb");
//    }
//    static void text( short s ){
//        System.out.println("sss");
//    }
    static void text( char c ){
        System.out.println("ccc");
    }
//    static void text( int i ){
//        System.out.println("iii");
//    }
}
java 复制代码 
package chapter04;

public class java_18Object_3 {
    public static void main(String[] args) {
        BBB aaa = new BBB();
        text(aaa);
        //多态就是为了约束了对象的使用场景
        //方法的重载：方法的名相同，参数的数量，类型，顺序不同；
        //找不到往他的父类找
        //AAA --》Object；
        //BBB--》AAA--》Object；
    }
    static void text ( AAA aaa ){
        System.out.println("aaa");
    }
    static void text ( BBB bbb ){
        System.out.println("bbb");
    }
}
class AAA{

}
class BBB extends AAA{

}

方法重写

java 复制代码 
package chapter04;

public class java_19Object {
    public static void main(String[] args) {
        Child19 c = new Child19();
        c.text();
        //TODO 面向对象------方法重写
        //方法的重写父类方法主要体现在通用性的，无法在特殊场合下使用；
        //如果子类需要在特殊场合写使用那么就需要方法的重写，这个操作在Java中称之为方法的重写；
        //这里的重写并不意味着父类方法被覆盖，只是在某种场合下不适用；但是仍然可以通过super访问；
        //重写的要求子类方法与父类方法相同，方法名相同，返回值相同，参数列表相同；
        }
}
class Parent19{
    String name = "lisi";
    void text (){
        System.out.println("parent...");
    }
}
class Child19 extends Parent19{
    String name = "刘宇";
    void text(){
        System.out.println("child...");
        super.text();
//        System.out.println(this.name);
//        System.out.println(super.name);
    }
}

方法重写小练习

csharp 复制代码 
package chapter04;

public class java_19Object_1 {
    public static void main(String[] args) {
        CCC ccc = new DDD();
        System.out.println(ccc.sum());
        //一个对象能使用什么方法取决于对象声明类型；
        //一个对象能使用什么属性取决于对象声明类型；
        //一个对象方法的具体使用取决于具体的对象；
        //一个对象属性的具体使用不需要看具体的对象，属性在哪里声明就在那里使用；
    }
}
class CCC{
    int i = 10;
    int sum (){
        return getI() + 10;
    }
    int getI(){
        return i;
    }
}
class DDD extends CCC{
    int i = 20;
    int sum () {
        return 20 + i;
    }
    int getI(){
        return i;
    }
}

递归

csharp 复制代码 
package chapter04;

public class java_20Object {
    public static void main(String[] args) {
        System.out.println(qiouhe(10 ));
        System.out.println(jiechen( 5 ));
        //1 递归的参数要有跳出的逻辑；
        //2 递归的数据要有一定的规律；
        
    }
    static int qiouhe(int i){
        if(i == 1){
            return 1;
        }
        if(i % 2 != 0 ) {
            return qiouhe( i - 1) + i;
        }
        else return qiouhe( i - 1);
    }
    static int jiechen ( int i ) {
        if( i == 0 ) {
            return 1;
        }else {
            return i * jiechen( i - 1 );
        }
    }
}

访问权限

typescript 复制代码 
package chapter04;

public class java_21Object {
    private String name;
    public String sex;
    String username;
    public static void main(String[] args) {
        //TODO 面向对象 -访问权限
        //  先访问类再访问属性或方法；
        //  1 private 私人的，只有在同一个类中可以使用；
        //  2 (default) 默认权限，当不提供任何权限的时候，JVM会默认提供权限，包（路径）权限 同一个包里随便用
        //  3 protected 受保护的权限，子类可以访问；
        //  4 public 公共的，任意使用；
        User21 user = new User21();
        //user.name;
    }
}
class User21{
    private String name;
    public String sex;
    String username;
    void text (){
        System.out.println(name);
    }
    void text1(){
        System.out.println("liuyu");
    }
}

访问权限练习题

java 复制代码 
package charter04;

public class java_22object {
    public static void main(String[] args) {
        Parent22 parent = new Parent22();
        //访问权限其实就是访问权力方法的限制
        //有两个问题：
        // 谁访问？类java_22object
        // 访问谁的？Parent17--->java.long.Object;

        //parent.clone();
    }
    java_22object liuyu = new java_22object();
}
class Parent22{

}

内部类

java 复制代码 
package charter04;

public class java_23Object {
    public static void main(String[] args) {
        //TODO 面向对象-内部类
        //java不允许外部类使用private，protected
        //外部类就是直接在源代码中声明的类，
        //内部类就是在类中声明的类；

        //把外部类当成属性使用即可；

        //因为内部类可以当成属性使用，所以要先声明类的对象，才能使用；
        Outclass other = new Outclass();
        Outclass.Innerclass innerclass =  other.new Innerclass();
        System.out.println(innerclass.name);
    }
}
class Outclass{
    class Innerclass{
        String name = "liuyu";
    }

}

单例设计方式

java 复制代码 
package charter04;

public class java_24Object {
    static int num = 10;
    static void jia( int num ){
        num = 20;
    }


    public static void main(String[] args) {
        User24 user1 = User24.instance();
        User24 user2 = User24.instance();
        User24 user3 = User24.instance();
        System.out.println( user1 == user2 );
    }
}
class User24{
    private static User24 user24 = null;//在自己类里面创建一名为user24的User24的变量并让其指向空

    private User24(){

    }
    public  static User24 instance(){
        if( user24 == null ){
            user24 = new User24();
        }
        return user24;
    }

}

fianl

arduino 复制代码 
package charter04;

public class java_25Object {
    public static void main(String[] args) {
        //TODO 面向对象 final
        //Java中提供了一种关键字final，可以保证数据初始化后不可改变；
        //final 可以修饰变量，变量被修饰后不可更改初始化的值；
        //final 可以修饰属性，修饰属性后JVM不会默认给属性初始化了；需要自己初始化；
        //一般将final修饰后的变量叫做常量或者不可变量；
        //final可以修饰方法，修饰后子类不可以进行方法重写了；
        //final可以修饰类，修饰之后就没有子类了；
        //final不可以修饰构造方法，因为构造方法本来就无法重写；
        //final还可以修饰方法参数，修饰后不可以更改；
        final int age = 10;
        System.out.println(age);
        //age = 20;
       // User25 user25 = new User25( 25 );
        //System.out.println(user25.age);
    }
}

final class User25 {
    //public final int age ;JVM不会给初始化了；
//TODO 属性final初始化方法
//1
// public final int age = 20;第一种初始化方法；

//   2
//    public final int age;
//    public User25 ( int age ){
//        this.age = age;
//    }

//   3
//    public final int age;
//    public User25 (  ){
//        age = 30;
//    }
    
//  TODO 方法final

    
// TODO 参数

//    public int age = 10;
//    int jia( final int age ){
//        age = 30;
//        return age;
//    }
//    
//}
//class User25Child extends User25{
//    public void jia (){
//       
//    }
//    
//}

抽象

typescript 复制代码 
package charter04;

public class java_26Object {
    public static void main(String[] args) {
        //TODO 面向对象 抽象
        //抽象类
        //抽象方法
        //分析问题 对象（具体）------》类（抽象）
        //编写代码 类（抽象）------》对象（具体）

    }
}
csharp 复制代码 
package charter04;

public class java_26Object {
    public static void main(String[] args) {
        //TODO 面向对象 抽象
        //抽象类
        //不完整的类就是抽象类
        //语法 :abstract class 类名；
        //抽象方法
        //不完整的方法就是抽象方法；
        //语法 :abstract 返回值 方法名 (参数)；


        //分析问题 对象（具体）------》类（抽象）
        //编写代码 类（抽象）------》对象（具体）

        //如果一个方法是抽象方法，那么它的类一定是抽象类；
        //如果一个类是抽象类，那么它的方法不一定是抽象方法；

        //抽象类无法直接构造对象，可以通过子类间接构建对象；
        //如果抽象类中含有抽象方法，那么子类继承抽象类需要把抽象类中的抽象方法重写；

        //final 不可以与 abstract 同时使用
        //final 与抽象类使用 不能有子类；
        //final 与抽象方法使用 不能有方法的重写；
        //Person26 p = new Person26();
        Chinese c = new Chinese();
        c.run();
        c.eat();

    }
}
abstract class Person26{

    public abstract void eat();//有一个抽象方法类必然是抽象类
    public void run (String guoji){
        System.out.println(guoji + "人用两个腿走路");
    }//抽象类中可以有非抽象方法；

}
class Chinese extends Person26{
    String guoji = "中国";
    public void run(){
        super.run(guoji);
    }
    public  void eat(){
        System.out.println("中国人用筷子吃饭");
    }

}

接口

java 复制代码 
package charter04;

public class java_27Object {
    public static void main(String[] args) {
        //TODO 面向对象-接口；
        //接口其实就是一种规则
        //基本语法 interface 接口名 {规则属性 ，规则行为}
        //接口其实是一种抽象
        //接口规则属性是公共的，并且被定义后不可修改；
        //规则属性应该是静态的；
        //规则行为是公共的，抽象的；
        //接口和类是两个层面的东西；
        //接口可以继承其他接口
        //类的对象需要遵循接口，这个遵循需要实现（implements）,类需要实现接口，并且可以实现多个接口；
        Computer c = new Computer();
        Light light = new Light();
        c.usb1 = light;
        Light light2 = new Light();
        c.usb2 = light2;
        c.Supply();
    }
}
interface USBInterface {

}
interface USBSupply extends USBInterface{
    public void Supply();
}

interface USBServes extends USBInterface{
    public void Serves();
}
class Computer implements USBInterface{
    USBServes usb1;
    USBServes usb2;
    public void Supply(){
        System.out.println("电脑提供电源");
        usb1.Serves();
        usb2.Serves();
    }

}
class Light implements USBServes{
    public void Serves(){
        System.out.println("灯接收电源");
    }
}

枚举

arduino 复制代码 
package charter04;

public class java_28Object {
    public static void main(String[] args) {
        //TODO 面向对象 枚举
        //枚举是一种特殊的类；其中包含了一组特定的对象，对象不能更改；这些对象一般用大写的标识符；
        //枚举使用enum关键字；
        //枚举类不能在外部创建对象；
        System.out.println(City.BEIJING.name);
        System.out.println(MyCity.BEIJING.code);
    }
}
class MyCity{
    String name;
    int code;
    private  MyCity( String name , int code ){
        this.name = name;
        this.code = code;
    }

    public static final MyCity BEIJING = new MyCity("北京", 30);
    public static final MyCity TIANJIN = new MyCity("天津", 20);

}


enum City{
    BEIJING ("北京",10),SHANGHAI("上海", 120);
    String name;
    int code;
    City( String name , int code ){
        this.name = name;
        this.code = code;
    }
}

匿名类

typescript 复制代码 
package charter04;

public class java_29Object {
    public static void main(String[] args) {
        //TODO 面向对象-匿名类；
        //在某些场合下类的名字不重要，我们只需要类的方法或功能；我们可以使用匿名类（抽象类，接口）；
        //
        Me me = new Me();
        me.sayHello(new Person29() {
            @Override
            public String name() {
                return "liuyu";
            }
        });
        //抽象类直接用抽象类的方法，在使用抽象类的方法的过程中直接补全方法；

        me.sayHello( new Person29(){
            public String name(){
                return "liuxuqiang";
            }
        });
        new Bird29().fly();

        new Fly(){
            public void fly(){
                System.out.println("用飞行器飞");
            }
        }.fly();//接口直接飞不在乎对象只在乎功能；


    }
}

interface Fly{
    public void fly();
}
class Bird29 implements Fly{
    public void fly(){
        System.out.println("鸟儿用翅膀飞");
    }
}

abstract class Person29{
    public abstract String name();
}
class Me{
    public void sayHello( Person29 person29 ){
        System.out.println("hello" + person29.name());
    }
}
class Liuyu extends Person29{
    public String name(){
        return "liuyu";
    }
}

bean

typescript 复制代码 
package charter04;

public class java_30Object {
    public static void main(String[] args) {
        //TODO 面向对象 bean
        //类的功能
        //1 编写逻辑
        //2 建立数据模型（bean）
        //类必须含有公共，无参的构造方法；
        //类的属性必须私有话，提供公共的set,get方法
        User30 user = new User30();
        user.setAccount("liuyu");
        user.setpassword("111");
        System.out.println(login30(user));

    }
    public static boolean login30( User30 user ){
        if(user.getAccount() == "liuyu" && user.getPassword() == "111"){
            return true;
        }else {
            return false;
        }
    }

}
class User30{
    private String account;
    private String password;
    public void setAccount (String account){
        this.account = account;
    }
    public void setpassword (String password){
        this.password = password;
    }
    public String getAccount(){
        return account;
    }
    public String getPassword(){
        return password;
    }

}
相关推荐
在下木子生9 分钟前
SpringBoot条件装配注解
java·spring boot·后端
huan9932 分钟前
Obsidian 插件篇 - 插件汇总简介
后端
周Echo周34 分钟前
5、vim编辑和shell编程【超详细】
java·linux·c++·后端·编辑器·vim
AronTing40 分钟前
03-深入解析 Spring AOP 原理及源码
后端
逻辑重构鬼才41 分钟前
AES+RSA实现前后端加密通信：全方位安全解决方案
后端
卤蛋七号1 小时前
JavaSE高级(一)
后端
Java中文社群1 小时前
SpringAI用嵌入模型操作向量数据库！
后端·aigc·openai
暴力袋鼠哥1 小时前
基于Flask的跨境电商头程预警分析系统
后端·python·flask
一只爱撸猫的程序猿2 小时前
防止外部API服务不可用拖垮系统的解决方案
spring boot·后端·程序员
白露与泡影2 小时前
SpringBoot 最大连接数及最大并发数是多少？
spring boot·后端·firefox
热门推荐
01我决定放弃搞 Java 了02DeepSeek各版本说明与优缺点分析03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04HTML项目一键打包工具：HTML2EXE 最新版05RAG 实践- Ollama+RagFlow 部署本地知识库06如何在WPS和Word/Excel中直接使用DeepSeek功能07苍穹外卖面试总结08本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程09DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具10【笔记】MJ Prompt