Java基础——面向对象

1.抽象Abstract:抽象类和抽象方法;

抽象类:不完整的类,就是抽象类:abstract class 类名;

抽象方法:只有声明,没有实现的方法;

abstract 返回值类型 方法名(参数);

因为类不完整,所以无法直接构建对象;抽象类无法直接构建对象,但是可以通过子类间接构建对象;

如果一个类中含有抽象方法,那么这个类是抽象类;

如果一个类是抽象类,他的方法不一定是抽象方法;

例如:

复制代码
import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
    Child c = new Child();
    c.eat();
    }

}
abstract class Person{
    public abstract void eat();
}
class Child extends Person{
    public void eat(){
        System.out.println("中国人");
    }
}

注意:在抽象类中只需声明方法即可;再在子类中把方法进行补充;

小心:abstract关键字不能和final同时使用;

2.接口:

所谓的接口,可以简单理解为规则;

基本语法: interface 接口名称{ 规则属性, 规则的行为};

接口其实是抽象的;

规则的属性必须是固定值,而且不能修改;

属性和行为的访问权限必须为公共的;

属性应该是静态的;

行为应该是抽象的;

接口和类是两个层面的东西;

接口可以继承其他接口;

类的对象需要遵循接口,在Java中,这个遵循,称之为实现(implements),类需要实现接口,而且可以实现多个接口;

例如:

复制代码
import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
    Computer c = new Computer();
    Light light = new Light();
    c.usb1 = light;
    Light light1 = new Light();
    c.usb2 = light1;
    c.powerSupply();
    }

}
interface USBInterface{

}
interface USBSupply extends USBInterface{
    public void powerSupply();
}
interface USBReceive extends USBInterface{
    public void powerReceive();
}
class Computer implements USBSupply{
    public USBReceive usb1;
    public USBReceive usb2;
    public void powerSupply(){
        System.out.println("电脑提供能源");
        usb1.powerReceive();
        usb2.powerReceive();
    }
}
class Light implements USBReceive{
    public void powerReceive(){
        System.out.println("电灯接收能源");
    }
}

首先定义了USB接口的规则,然后分别让supply和receive分别继承该规则,然后让计算机和台灯分别满足对应规则,计算机中定义两个usb接口,定义能源提供的方法;light中定义能源接收的方法;

3.枚举:

枚举是一个特殊的类,其中包含了一组特定的对象,这些对象不会发生改变,一遍都使用大写的标识符。

枚举使用enum关键字使用;

枚举类会将对象放置在最前面,那么和后面的语法需要使用分号隔开;

枚举类不能创建对象,它的对象是在内部自行创建;

例如:

复制代码
import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
        System.out.println(City.BEIJING.name);
        System.out.println(City.SHANGHAI.code);
    }

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

创建了两个城市,在构造时传参,并赋值给城市的属性,这样就达到了创建类的一个效果;

4.匿名类:

复制代码
import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
    Me me = new Me();
    me.sayHello(new Zhangsan());
    }

}
abstract class Person{
    public abstract String name();
}
class Me{
    public void sayHello(Person person){
        System.out.println("Hello " + person.name());
    }
}
class Zhangsan extends Person{
    public String name(){
        return "zhangsan";
    }
}

创建一个me对象,然后调用sayhello方法,传入一个Zhangsan类的对象,他是改写的抽象类Person的所以将对象传进去,打印hello+name;

也可以这样写:

复制代码
import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
    Me me = new Me();
    me.sayHello(new Person() {
        @Override
        public String name() {
            return "wangwu";
        }
    });
    }

}
abstract class Person{
    public abstract String name();
}
class Me{
    public void sayHello(Person person){
        System.out.println("Hello " + person.name());
    }
}

直接传入抽象的类并在小括号内进行函数方法的初始化;

再例:

复制代码
import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
        Bird b = new Bird();
        b.fly();
    }

}
interface Fly{
    public void fly();
}
class Bird implements Fly{
    public void fly(){
        System.out.println("使用翅膀飞翔");
    }
}

转换为对应的匿名类模式:

复制代码
import java.util.concurrent.Callable;

public class java_3_24
{
    public static void main(String[] args) {
        new Fly(){
            @Override
            public void fly() {
                System.out.println("使用飞行器飞翔");
            }
        }.fly();
    }

}
interface Fly{
    public void fly();
}

5.建立数据模型:

Bean类的设计规范:Bean规范:

(1)类要求必须含有无参,公共的构造方法;

(2)属性必须私有化,然后提供公共的set,get方法;

一个简单的登陆系统:

复制代码
public class java_3_24
{
    public static void main(String[] args) {
        User user = new User();
        user.account = "admin";
        user.password = "admin";
        System.out.println(login(user));

    }
    public static boolean login(User user){
        if (user.account.equals("admin") && user.password.equals("admin")){
            return true;
        }else {
            return false;
        }
    }
}
class User{
    public String account;
    public String password;
}

优化后:

复制代码
public class java_3_24
{
    public static void main(String[] args) {
        User user = new User();
        user.setAccount("admin");
        user.setPassword("admin");
        System.out.println(login(user));

    }
    public static boolean login(User user){
        if (user.getAccount().equals("admin") && user.getPassword().equals("admin")){
            return true;
        }else {
            return false;
        }
    }
}
class User{
    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 分钟前
神经网络:从基础到应用,开启智能时代的大门
java·人工智能·python·深度学习·神经网络·算法·机器学习
柠石榴18 分钟前
【python编程从入门到到实践】第四章 操作列表
开发语言·python
MiniFlyZt21 分钟前
分布式数据库TiDB:架构、核心特性与生产实践(分库分表)
java·数据库·分布式·spring cloud·微服务·tidb
zzx_nihao29 分钟前
Java29:Spring MVC
java·spring·mvc
JAVA坚守者32 分钟前
Java 服务器端 jar 包内 class 文件替换与配置文件修改高级技术指南
java·pycharm·jar
化作晚霞32 分钟前
JVM有什么调优参数?
java·开发语言·jvm
callJJ36 分钟前
Floyd算法求解最短路径问题——从零开始的图论讲解(3)
java·算法·动态规划·图论·dijkstra算法·floyd算法·最短路径问题
浩哲Zhe40 分钟前
Java Web 之 Tomcat 100问
java·前端·tomcat
Jtti41 分钟前
PHP日志会对服务器产生哪些影响?
服务器·开发语言·php
Seven971 小时前
JDK的SPI有什么缺陷?dubbo做了什么改进?
java·dubbo