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;
}
}