JavaSE笔记

Chj_aa

已于 2022-02-09 19:06:44 修改

阅读量106

点赞数

文章标签： java

于 2021-09-19 10:20:48 首次发布

本文链接：https://blog.csdn.net/Chj_aa/article/details/120377902

版权

标识符

标识符可以包含英文字母26个（区分大小写），0-9数字，$美元符号和_下划线。

标识符不能以数字开头。

标识符不能是关键字

命名规范

类名规范：首字母大写，后面每个单词的首字母大写（大驼峰式）。

变量名规范：首字母小写，后面每个首字母大写（小驼峰式）。

方法名规范：同变量名。

数据类型

数据类型	关键字	内存占用	取值范围
字节型	byte	1个字节	-128~127
短整型	short	2个字节	-32768~32767
整型	int	4个字节	-2的31次方~2的31次方-1
长整型	long	8个字节	-2的64次方~2的64次方-1
单精度浮点数	float	4个字节	1.4013E-45~3，4028E+38
双精度浮点数	double	8个字节	4.9E-324~1.7977E+308
字符型	char	2个字节	0-65535
布尔类型	boolean	1个字节	true、false

数据类型转换

自动转换：小变大

强制转换：范围小的类型范围小的变量名=（范围小的类型）范围大的数据

byte、short、char使用运算符会自动提示为int，然后计算

ASCII码：48-'0'、65-‘A’、97-‘a’

运算符

算术运算符
+	加法运算，字符串连接运算
-	减法运算
*	乘法运算
/	除法运算
%	取模运算，两个数字取余数
++、--	自增自减运算 ++i先+再用，i++先用再加

赋值运算符
=	等于
+=	加等于
-=	减等于
*=	乘等于
/=	除等于
%=	取模等于

比较运算符
==	比较符号两边数据是否相等，相等结果为ture
<	比较符号左边的数据是否小于右边的数据，如果小于结果为true
>	比较符号左边的数据是否大于右边的数据，如果大于结果为true
<=	比较符号左边的数据是否小于等于右边的数据，如果小于等于结果为true
>=	比较符号左边的数据是否大于等于右边的数据，如果大于等于结果为true
!=	如果符号两边的数据不相等，结果为true

逻辑运算符	与或非
与（并且）&&	全为true，才是true，否则为false
或（或者）\|\|	至少有一个是true，就是true，全都是false，才是false
非（取反）！	非（取反）！本来是true，变成false，本来是false，变成true

三元预算符

数据类型变量名称=条件判断? 表达式 A ：表达式B

流程：首先判断条件成不成立，如果成立，那么将表达式A的值赋值给左侧的变量

如果不成立那么将表达式B的值赋值给左侧的变量；

注意：表达式A和表达式B必须都满足左侧数据类型的要求，三元运算符的结果必须被使用

public class demo {
    public static void main(String[] args) {
        int a=1;
        int b=2;
        int c=a>b ? a:b;
        System.out.println(c);\输出2
}
}

方法的定义

方法:：将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。当我们需要这个功能的时候就可以去调用。实现了代码的复用性，也解决了代码的冗余。

修饰符返回值类型方法名（参数列表）{

代码···

return ；

}

流程控制

判断语句 if....else,if....else if....else

选择语句 switch....case....default

循环语句 for，while，do....while，跳出循环break，continue

IDEA

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQ2hqX2Fh,size_20,color_FFFFFF,t_70,g_se,x_16

数组

数组定义

动态数组：数据类型 [ ] 数组名称 =new 数据类型 [ 数组个数 ]；

静态数组：数据类型 [ ] 数组名称 =new 数据类型 [ ] { 数组的数据 }；

省略写法：数据类型 [ ] 数组名称={ 数组的数据 }

获取数组的数据用数组名加index索引值：arr[0]

JAVA内存划分

JAVA内存
1.栈（Stack）	存放的都是方法中的局部变量，方法的运行一定要在栈中运行。局部变量：方法的参数，或者是{}内部的变量作用域：一旦超出作用域，立刻从栈内存中消失
2.堆（Heap）	凡是new出来的东西都在堆当中。堆内存里面的东西都有一个地址值：16进制堆里面的数据都有默认值：byte、short、int、long为0，double、float为0.0，char为，boolean为false，引用类型为null。
3.方法区（Method Area）	存储.class相关信息，包含方法的信息
4.本地方法栈（Native Method Stack）	与操作系统相关
5.寄存器（pc Register）	与cpu相关

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQ2hqX2Fh,size_20,color_FFFFFF,t_70,g_se,x_16

面向对象

面向过程：当实现一个功能的时候，每一个具体的步骤都要亲历亲为，详细处理每一个细节

面向对象：当实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人来帮我做事。

特点：面向对象是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥官，面向对象的语言中包含了三大基本特征，封装，继承和多态。

类

类：类是一组相关属性和行为的集合，可以看成是一类事物的模板使用具体事物的属性特征和行为特征来描述该类事物。

属性：就是该事物的状态信息

行为：就是该事物能做什么

例：小猫

属性：年龄，花色，名字

行为：吃饭，抓老鼠

什么是对象

对象：对一类事物的具体表现，对象是类的一个实例，必然具备该类事物的属性和行为。

类与对象的关系

类是对一类事物的描述，是抽象的

对象是一类事物的实例，是具体的

类是对象的模板，对象是类的实体

类的定义

public class demo{

成员变量

成员方法

}

局部变量和成员变量

	局部变量	成员变量
定义的位置	在方法的内部	在方法的外部，直接写在类当中
作用范围	在方法当中才可以使用，出了方法就不能再用	整个类都可以通用
默认值	没有默认值，如果想用，必须手动赋值	如果没有赋值会有默认值，规则和数组一样
内存位置	位于栈内存	位于堆内存
生命周期	随着方法进栈诞生，随着方法出栈而消失	随着对象创建诞生，随着被垃圾回收而消失

一个对象的内存图

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQ2hqX2Fh,size_20,color_FFFFFF,t_70,g_se,x_16

两个对象的内存图

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQ2hqX2Fh,size_20,color_FFFFFF,t_70,g_se,x_16

两个对象指向一个方法的内存图

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQ2hqX2Fh,size_20,color_FFFFFF,t_70,g_se,x_16

使用对象类型作为方法参数

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQ2hqX2Fh,size_20,color_FFFFFF,t_70,g_se,x_16

使用对象作为方法返回值

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQ2hqX2Fh,size_20,color_FFFFFF,t_70,g_se,x_16

面向对象的三大特性：封装，继承，多态

封装：

1.方法就是一种封装

2.关键字private也是一种封装，被private修饰的变量无法直接修改，可以通过setter，getter方法间接修改

CLASS Person
public class Person{
    String name;
    private int age;
    public void show(){
        System.out.println("我是："+name+"，今年"+age+"岁了);
    }
    public void setAge(int num){
        age=num;
    }
    public int getAge(){
    return age;
    }
}

CLASS Demo
public class Demo{
    public static void main(String[] args){
    Person man=new Person();
    man.name="jack";
    man.setAge=18;
    man.show();
    }
}

this关键字：通过谁调用的方法谁就是this

构造方法

1.构造方法的名称必须和所在类的名称完全一样

2.构造方法不要写返回值连void都不写

3.构造方法不能return一个具体的返回值

4.如果没写构造方法编译器默认赠送一个构造方法，没有参数，没有方法体，什么都不做

5.一但编写了至少一个构造方法，那么编译器不再赠送。

6.构造方法也是可以重载的，可以通过参数重载，方法名称相同，参数列表不同。

一个标准的类

1.所有的成员变量都要使用private关键字修饰

2.为每一个成员变量编写一对Getter和Setter方法

3.编写一个无参数的构造方法

4.编写一个全参数的构造方法

class Student
public class Student {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Student(){
    }
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
}

class demo01
public class Demo01 {
    public static void main(String[] args) {
        Student stu=new Student();
        stu.setName("jack");
        stu.setAge(18);
        System.out.println("姓名："+stu.getName()+",年龄"+stu.getAge());
        System.out.println("==========================");
        Student stu2=new Student("rose",16);
        System.out.println("姓名："+stu2.getName()+",年龄"+stu2.getAge());
    }
}

匿名对象

只有右边的对象，没有左边的赋值对象和运算符

new Xxx（）;

匿名对象只能使用一次，下次使用不得不创建一个新的对象。

匿名对象作为参数和返回值的使用

import java.util.Scanner;
public class demo {
    public static void main(String[] args) {
        System.out.println("请输入第一个数：");
        method(new Scanner(System.in));
        System.out.println("请输入第二个数：");
        Scanner sc=methodReturn();
        int a=sc.nextInt();
        System.out.println("那个是："+a);
    }
    public static void method(Scanner sc){
        int b=sc.nextInt();
        System.out.println("这个是："+b);
    }
    public static Scanner methodReturn(){
        return new Scanner(System.in);
    }
}

继承

继承是多态的前提，如果没有继承就没有多态，继承主要解决的问题是：共性抽取

特点:1.一个类的直接父类只能有唯一一个 2.父类可以有多个子类

继承中父类与子类相当于师父和徒弟的关系，师父会什么徒弟就会什么。

定义格式

public class Father{

}

public class Son extends Father{

}

在父子类的继承关系中，如果成员变量重名，则创建子类对象是访问有两种方式

直接通过子类对象访问成员变量

等号左边是谁就优先用谁，没有则向上访问

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

方法属于谁优先用谁，没有则向上访问

访问父类变量用super，无论是成员方法还是变量，没有都是向上找父类，绝对没有向下找子类的

public class Son extends Father{
    String name="son";
    @Override
    public void method(){
        String name="grandson";
        System.out.println(name);//grandson
        System.out.println(this.name);//son
        System.out.println(super.name);//father
    }
}

重写（overrid）

概念：在继承关系中，方法的名称一样，参数列表也一样

特点：创建的是子类对象优先用子类的方法

重载（overload）方法的名称一样，参数列表不一样

@override：注释，检测方法是否重写

子类方法的返回值必须小于等于父类方法的返回值范围

object类是所有类的公共最高父类（祖宗类）

子类的方法权限必须大于等于父类方法的权限修饰符。

public>protect>空（default）>private

重写的设计原则：对于已经投入使用的类，尽量不要进行修改，推荐定义一个新的类，来重复利用其中共性内容，并且添加改动新内容。例：给手机发布新功能

class Father
public class Father {
    public void showNum(){
        System.out.println("来电显示");
    }
    public void sendMail(){
        System.out.println("发送短信");
    }
    public void callNum(){
        System.out.println("打电话");
    }
}
class Son
public class Son extends Father{
    @Override
    public void showNum(){
        super.showNum();//调用父类的整个showNum方法
        System.out.println("显示姓名");
        System.out.println("显示头像");
    }
}

继承中的构造方法

1.子类构造方法中一定会先调用父类的构造方法，然后执行子类的构造方法。

2.子类构造方法可以通过super关键字调用父类重载构造，super（）必须放在子类构造方法第一个语句

3.一个子类不能多次调用super（）

class father
public class Father {
   public Father(){
       System.out.println("父类无参构造");
   }
   public Father(int num){
       System.out.println("父类有参构造");
   }
}

class Son
public class Son extends Father{
    public Son(){
        super(10);
        System.out.println("子类构造方法");
    }
}

this关键字补充

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQ2hqX2Fh,size_20,color_FFFFFF,t_70,g_se,x_16

this和super调用内存图

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQ2hqX2Fh,size_20,color_FFFFFF,t_70,g_se,x_16

继承的例子发红包

class User
public class User {
    private String name;
    private int money;
    public User(){}
    public User(String name, int money) {
        this.name = name;
        this.money = money;
    }
    public void show(){
        System.out.println("我是"+name+",我有"+money+"块钱");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
}
class Manager
import java.util.ArrayList;
public class Manager extends User{
    public  Manager(){}
    public Manager(String name,int money){
        super(name,money);
    }
    public ArrayList<Integer> sendMoney(int redMoney,int count){
        ArrayList<Integer> moneyList =new ArrayList<>();
        int maMoney=super.getMoney();
        if(redMoney>maMoney){
            System.out.println("余额不足");
            return moneyList;
        }
        int avg=redMoney/count;
        int remainMoney=redMoney%count;
        for (int i = 0; i <count-1 ; i++) {
            moneyList.add(avg);
        }
        moneyList.add(avg+remainMoney);
        super.setMoney(maMoney-redMoney);
        return  moneyList;
    }
}
Class Member
import java.util.ArrayList;
import java.util.Random;

public class Member extends User{
    public Member(){}
    public Member(String name,int money){
        super(name,money);
    }
    public void reciveMoney(ArrayList<Integer> list){
        int index=new Random().nextInt(list.size());
        int meMoney=list.remove(index);
        int money=super.getMoney();
        super.setMoney(meMoney+money);
    }
}
Class main
import java.util.ArrayList;
public class DemoRedPacket {
    public static void main(String[] args) {
        Manager manager = new Manager("群主",100);
        Member member1 = new Member("成员A",0);
        Member member2 = new Member("成员B",0);
        Member member3 = new Member("成员C",0);
        manager.show();
        member1.show();
        member2.show();
        member3.show();
        System.out.println("========================");
        ArrayList<Integer> list1=manager.sendMoney(20,3);
        member1.reciveMoney(list1);
        member2.reciveMoney(list1);
        member3.reciveMoney(list1);
        manager.show();
        member1.show();
        member2.show();
        member3.show();
        System.out.println("========再发一次=========");
        ArrayList<Integer> list=manager.sendMoney(20,3);
        member1.reciveMoney(list);
        member2.reciveMoney(list);
        member3.reciveMoney(list);
        manager.show();
        member1.show();
        member2.show();
        member3.show();
    }
}

抽象类

抽象类：抽象方法所在的类，必须是抽象类，在class之前加上abstract

抽象方法：加上abstract，去掉大括号，直接分号结束

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQ2hqX2Fh,size_20,color_FFFFFF,t_70,g_se,x_16

class Animal
public abstract class Animal {
    public abstract void eat();
}
class Cat
public class Cat extends Animal{
    public void eat(){
        System.out.println("i eat fish");
    }
}
class Demo04Abstract
public class Demo04Abstrack {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
    }
}

抽象类注意事项

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQ2hqX2Fh,size_20,color_FFFFFF,t_70,g_se,x_16

接口

接口就是一种公共的规范，只要符合规范标准，就可以大家通用

定义一个接口：

public interface 接口名称{

//接口内容：常量，抽象方法，默认方法，静态方法，私有方法

}

public abstract 返回值类型方法名（参数列表）；

注意事项：1，接口当中的抽象方法，修饰符必须是两个固定的关键字public abstract

2，这两个关键字可以选择性忽略

使用：接口不能直接使用，必须使用一个实现类来实现该接口，接口的实现必须覆盖重写接口中的抽象方法，去掉abstract 加上方法体大括号。

格式：public class implements 接口名称{

}

从java 8开始接口允许定义默认方法，和静态方法

默认方法：

public default 返回值类型方法名称（参数列表）{

}用于解决接口升级问题

默认方法可以覆盖重写

静态方法：

public static 返回值类型方法名称（参数列表）{

}

注意：不能通过接口实现类的对象调用接口中的静态方法，而是用接口名称直接调用其中的静态方法

从java 9开始接口允许定义私有方法用于解决代码重复问题

private 返回值类型方法名称（参数列表）{

}

private static 返回值类型方法名称（参数列表）{

}

class MyInterface
public interface MyInterface {
    public abstract void oneAbstract();
    public default void defaultMethod(){//默认方法
        System.out.println("接口默认方法");
    };
    public static void staticMethod(){//静态方法
        System.out.println("接口静态方法");
    };
}
class UseInterface
public class UseInterface implements MyInterface{
    @Override
    public void oneAbstract() {
        System.out.println("重写方法");
    }
}
class MainClass
public class MainClass {
    public static void main(String[] args) {
        UseInterface useInterface = new UseInterface();
        useInterface.oneAbstract();
         useInterface.defaultMethod();//调用默认方法
        MyInterface.staticMethod();//调用静态方法
    }
}

接口使用成员常量必须使用public static final 这三个关键字修饰

格式：

public static final 数据类型常量名称（全大写）=数据值；

接口使用注意事项：

1.接口没有静态代码块或者构造方法的

2.一个类可以同时实现多个接口

public class UseInterface implements MyInterfaceA ，MyInterfaceB{

//重写方法

}

3.多个接口有重复的抽象方法，只需要重写一次即可

4.对多个接口有重复的默认方法，必须重写。

5.一个类的父类方法和接口中的方法冲突，优先使用父类中的方法

多态：

extends继承和implements实现，是多态的前提

一个对象用的多种形态就是多态。

代码中体现多态性，就是父类引用子类对象

父类对象=new 子类（）;

class Father
public class Father{
    int num=10;
    public void method(){
        System.out.println("父类中的方法");
    }
    public void FaMethod(){
        System.out.println("父类中的新方法");
    }
}
class Son
public class Son extends Father{
    int num=20;
    @Override
    public void method(){
        System.out.println("子类中的方法");
    }
}
class MainMethod
public class MainMethod {
    public static void main(String[] args) {
        Father obj=new Son();
        //直接通过对象访问成员变量，等号左边是谁优先用谁，没有则向上找
        System.out.println(obj.num);//10
        obj.method();//子类中的方法
        obj.FaMethod();//父类中的新方法
    }
}

多态访问成员变量的特点

1.直接通过对象访问成员变量，等号左边是谁优先用谁，没有则向上找

2.间接通过成员方法访问成员变量，该方法属于谁，优先用谁，没有则向上找

接口和多态的实例

class interface Usb
public interface Usb {
    public abstract void powerOn();
    public abstract void powerOff();
}
class Mouse
public class Mouse implements Usb{
    @Override
    public void powerOn() {
        System.out.println("打开鼠标");
    }
    @Override
    public void powerOff() {
        System.out.println("关闭鼠标");
    }
    public void clickMouse(){
        System.out.println("点击鼠标");
    }
}
class Keyboard
public class Keyboard implements Usb{
    @Override
    public void powerOn() {
        System.out.println("打开键盘");
    }
    @Override
    public void powerOff() {
        System.out.println("关闭键盘");
    }
    public void clickKeyboard(){
        System.out.println("键盘输入");
    }
}
class Computer
public class Computer {
    public void openComputer(){
        System.out.println("开机");
    }
    public void useComputer(Usb usb){
        if(usb instanceof Mouse mouse){
            mouse.clickMouse();
        }if (usb instanceof Keyboard keyboard){
            keyboard.clickKeyboard();
        }
    }
    public void closeComputer(){
        System.out.println("关机");
    }
}
class MainComputer
public class MainComputer {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.openComputer();
        Usb mouse=new Mouse();
        mouse.powerOn();
        Usb keyboard=new Keyboard();
        keyboard.powerOn();
        computer.useComputer(mouse);
        computer.useComputer(keyboard);
        mouse.powerOff();
        keyboard.powerOff();
        computer.closeComputer();
    }
}

final关键字

可以用于定义一个类，方法，成员变量，局部变量

定义类：public final class 类名{}

含义：当前这个类不能有任何子类。

定义方法：public final void 方法名（）{}

含义：这个类不能被重写

定义局部变量： final 数据类型变量名

含义：一旦使用final修饰局部变量那么它（地址值）就不能进行改变。

定义成员变量： final 数据类型变量名

含义：一旦使用final修饰成员变量那么它就不能进行改变。

注意：成员变量有默认值，所以用了final后必须手动赋值，对于成员变量要么直接赋值，要么通过构造方法赋值二者选一。

四种权限修饰符

public > protected > (default) > private

同一个类： YES YES YES YES

同一个包： YES YES YES NO

不同包子类： YES YES NO NO

不同包非子类：YES NO NO NO

内部类

一个类包含另一个类，如身体和心脏

分类：成员内部类，局部内部类

成员内部类定义格式：

修饰符 class 类名{

修饰符 class 内部类名称

} 注意：内部类访问外部类，随意访问，外部类使用内部类需要内部类对象

使用方法：1.间接使用：在外部类的方法中，使用内部类；main只是调用外部类的方法

2.直接使用：在main方法中：

外部类名称.内部类名称对象名=new 外部类名称().new 内部类名称();

public class Body {
    private String name="外部成员变量";
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void bodyMethod(){//间接方式使用内部类
        System.out.println("外部类的方法");
        Heart heart=new Heart();
        heart.beat();
    }
    public class Heart{//内部类
        public void beat(){
            System.out.println("心脏跳动");
            System.out.println(name);//可以方法外部
        }
    }
}
class InnerClass
public class InnerClass {
    public static void main(String[] args) {
        Body body=new Body();
        body.bodyMethod();
        System.out.println("===============");
        Body.Heart heart=new Body(). new Heart();//直接使用内部类
        heart.beat();
    }
}

内部类使用外部类的重名成员变量：外部类.this.变量名称

System.out.println(num);//局部变量
System.out.println(this.num);//内部类成员变量
System.out.println(Outer.this.num);//外部类成员变量

局部内部类：如果一个类在一个方法的内部，那么这就是一个内部局部类

这个类只能在方法内部使用，出来方法就无法使用

定义格式：修饰符 class 外部类{

修饰符 void 方法名（）{

修饰符 class 内部类名称{

}}}

class Outer
public class Outer{
    public void method(){
         class Inner{
            int num=20;
           public void innerMethod(){
               System.out.println(num);
           }
        }
        Inner inner=new Inner();
         inner.innerMethod();
    }
}
class MainInner
public class MainInner {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();
    }
}

定义一个类的权限修饰符规则：

1外部类：public / (default)

2成员内部类：public / protected /(default)/ private

3局部内部类：什么都不能写

局部内部类访问局部变量，那么这个局部变量必须是有效的final的。原因是new 出来的对象是在堆当中，局部变量是跟着方法走的，在栈内存当中，方法运行结束后会立刻出栈，局部变量会立刻消失，但是new出来的对象会在堆当中持续存在，知道垃圾回收消失。

匿名内部类

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次

定义格式：

接口名称对象名 = new 接口名称（）{

//覆盖重写所有的抽象方法

}；

注意：

1创建对象的时候只能使用唯一一次

2匿名对象只能调用一次方法，如果需要同一个对象多次调用方法必须给对象起个名字

3匿名内部类是省略了实现类/子类，但是匿名对象是省略了对象名称。

强调匿名内部类和匿名对象不是一回事。

interface 
public interface OneInterface {
    public abstract void method();
}
class MainInterface
public class MainInterface {
    public static void main(String[] args) {
    OneInterface obj=new OneInterface() {
        @Override
        public void method() {
            System.out.println("匿名内部对象方法实现");
        }
    };
    obj.method();
    }
}

类和接口作为成员变量

interface Hobby
public interface Hobby {
    public abstract void interesting();
}
class Work
public class Work {
    private String type;
    public Work() {}
    public Work(String type) {
        this.type = type;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
}
class Person
public class Person {
    private String name;
    private int age;
    private Work work;//使用类作为成员变量
    private Hobby hobby;//使用接口作为成员变量
    public void method(){
        System.out.println("我叫"+name+",今年"+age+",我是"+work.getType());
        hobby.interesting();
    }
    public Person() {}

    public Hobby getHobby() {
        return hobby;
    }

    public void setHobby(Hobby hobby) {
        this.hobby = hobby;
    }

    public Person(String name, int age, Work work,Hobby hobby) {
        this.name = name;
        this.age = age;
        this.work=work;
        this.hobby=hobby;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Work getWork() {
        return work;
    }
    public void setWork(Work work) {
        this.work = work;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
class MainPerson
public class MainPerson {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("安安");
        person.setAge(20);
        Work work = new Work("会计");
        person.setWork(work);
        /*HobbyImp hobbyImp=new HobbyImp();
        person.setHobby(hobbyImp);或person.setHobby(new HobbyImp); 用实现类匿名对象实现接口忽略没写*/
        /*Hobby hobby=new Hobby() {
            @Override
            public void interesting() {
                System.out.println("我喜欢跳舞");
            }
        };
        person.setHobby(hobby);使用匿名内部类实现接口重写*/
        person.setHobby(new Hobby() {//使用匿名内部类和匿名对象实现接口重写
            @Override
            public void interesting() {
                System.out.println("我喜欢唱歌");
            }
        });
        person.method();
    }
}

接口作为方法参数和返回值

import java.util.ArrayList;
import java.util.List;
public class MainClass {
    public static void main(String[] args) {
        List<String> objects = new ArrayList<>();
        List<String> newList =new MainClass().method(objects);
        for (String s : newList) {
            System.out.println(s);
        }
    }
    public  List<String> method(List<String> list){//list是一个接口
        list.add("迪迦");
        list.add("赛文");
        list.add("泰罗");
        return list;
    }
}

XML解析

<?xml version="1.0" encoding="UTF-8"?>
<!--<!DOCTYPE person SYSTEM "data.dtd">-->

<person>
    <student id="1">
        <name id="11">程红军</name>
        <age>13</age>
        <gender>man</gender>
    </student>
    <student id="2">
        <name>安陌</name>
        <age>13</age>
        <gender>woman</gender>
    </student>
</person>

public class DemoJaxenTest {
    @Test
    public void useJaxen() throws Exception {
        SAXReader saxReader = new SAXReader();
        Document document = saxReader.read(DemoJaxenTest.class.getResourceAsStream("/chj.xml"));
        //单个子元素检索
        List<Node> nodes = document.selectNodes("/person/student/name");
        for (Node node : nodes) {
            System.out.println(node.getText());
        }
    }
    @Test
    public void useJaxen1() throws Exception {
        SAXReader saxReader = new SAXReader();
        Document document = saxReader.read(DemoJaxenTest.class.getResourceAsStream("/chj.xml"));
        //所有元素检索
        List<Node> nodes = document.selectNodes("//name");
        for (Node node : nodes) {
            System.out.println(node.getText());
        }
    }
    @Test
    public void useJaxen2() throws Exception {
        SAXReader saxReader = new SAXReader();
        Document document = saxReader.read(DemoJaxenTest.class.getResourceAsStream("/chj.xml"));
        //所有元素检索
        Node node = document.selectSingleNode("//name[@id=11]");
        String text = node.getText();
        System.out.println(text);
    }

}

Chj_aa

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE笔记

标识符标识符可以包含英文字母26个（区分大小写），0-9数字，$美元符号和_下划线。标识符不能以数字开头。标识符不能是关键字其它类名规范：首字母大写，后面每个单词的首字母大写（大驼峰式）。变量名规范：首字母小写，后面每个首字母大写（小驼峰式）。方法名规范：同变量名。...
复制链接

扫一扫