Java与代码审计-Java面向对象

Java面向对象

package com.woniuxy.basic;


//在一个源文件中定义多个类，但是Java中有一个public修饰的类，该类的类名必须与文件名一样
public class OOPDemo {
    public static void main(String[] args){
        People p = new People();
        p.setName("张三");
        System.out.println(p.getName());
    }
}

class People{
    private String name = "人名";
    public String sex = "性别";

    public void eat(){
        System.out.println("吃饭...");
    }

    public void sleep(){
        System.out.println("睡觉...</br>");
    }

    //仅能被类内部的其他方法调用
    private void output(){
        System.out.println("输出...");
    }

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return this.name;
    }
}

运行结果如下:

package com.woniuxy.basic;


//在一个源文件中定义多个类，但是Java中有一个public修饰的类，该类的类名必须与文件名一样
public class OOPDemo {
    public static void main(String[] args){
        //常规操作
//        People p = new People();
//        p.setName("张三");
//        System.out.println(p.getName());

        //直接通过构造方法传name值
        People p1 = new People("李四");
        System.out.println(p1.getName());

        //如果构造方法显式进行了声明，则注意实例化要求:必须要与构造方法参数匹配
        People p2 = new People();
        People p3 = new People("王五");
    }
}

class People{
    private String name = "人名";
    public String sex = "性别";

    //定义构造方法:将类名作为方法名
    public People(){
        //默认没有任何参数，没有做任何处理的构造方法
    }
    //重载新的构造方法:实例化可以传参
    public People(String name){
        this.name = name;
    }

    public void eat(){
        System.out.println("吃饭...");
    }

    public void sleep(){
        System.out.println("睡觉...</br>");
    }

    //仅能被类内部的其他方法调用
    private void output(){
        System.out.println("输出...");
    }

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return this.name;
    }
}

 运行结果如下:

继承

class Father extends People{
    //子类可以扩展父类（加新方法或新属性）
    public void drive(){
        System.out.println("驾驶...");
    }
}

//调用父类方法
Father f = new Father();
f.setName("父亲");
System.out.println(f.getName());

运行结果如下:

单一继承，Father同样可以继续作为父类

class Son extends Father{
    //重写父类方法:override
    public void drive(){
        System.out.println("赛车");
    }
    //重载本类方法:overload
    public void drive(String type){
        System.out.println("赛车类型为:" + type);
    }
}

可以使用父类声明，子类实例化的方式

Father s = new Son();
s.drive();
Father d = new Daughter();
d.drive();

//Object是所有Java对象的祖宗类（超级父类）
Object str = new String();
Object p = new People();
Object son = new Son();

关于String的equals方法，研究一下父类和子类对应的方法

Object类的equals方法，比较地址

public boolean equals(Object obj){
    return (this == obj);
}

而在String类中重写了equals方法，只进行值的比较

代码略

顺便发现定义String类的代码如下:

public final class String
    implements java.io.Serializable,Comparable<string>,CharSecquence

final关键字的意思是:本类不能被继承，是最低层的类，不能充当父类

抽象类

介于类与接口之间的一种类型，使用abstract class来定义:类是可以实现实例化，抽象类不可以实例化，只能继承，抽象类中的方法可以实现，抽象类中也可以定义成抽象方法abstract void function(),则不能被实现

abstract class Animal{
    //正常的类属性和方法
    public String type = "动物";
    public void eat(){
        System.out.println("吃饭");
    }
    //抽象方法必须在子类中进行重写
    public abstract void run();
}

class Dog extends Animal{
    public void run(){
        System.out.println("奔跑");
    }
}

接口

接口是一种极端情况下的抽象类，不能实例化，且接口中的方法不能被实现，全部转换为抽象方法

interface Phone{
    public void call();
    public void play();
}

class Huawei implements Phone{
    @Override
    public void call() {
        
    }

    @Override
    public void play() {
        
    }
}

List与ArrayList

一种扩展数组，增强了很多功能的java内置类

Map与HashMap

用于创建Key-Value键值对的对象，类似于PHP的关联数组或Python的字典

//列表的使用
List<Object> list = new ArrayList<>();
list.add("zhangsan");
list.add(123);
list.add("lisi");
People p = new People();
list.add(p);

for (Object item : list){
    System.out.println(item);
}

List<Integer> list2 = new ArrayList<Integer>();
list2.add(11111);
list2.add(22222);
list2.add(33333);
list2.add(44444);
System.out.println("44444");
list2.remove(1);

Map<String,String> map = new HashMap<>();
map.put("username","woniu");
map.put("password","123456");
map.put("phone","18812345678");
map.put("address","chengdu");
System.out.println(map.get("username"));

Map<String,String> map1 = new HashMap<>();
        map1.put("username","woniu");
        map1.put("password","1234561");
        map1.put("phone","188123456782");
        map1.put("address","chengdu");
//        System.out.println(map1.get("username"));

        Map<String,String> map2 = new HashMap<>();
        map2.put("username","woniu");
        map2.put("password","1234563");
        map2.put("phone","188123456784");
        map2.put("address","chengdu");
//        System.out.println(map2.get("username"));

        Map<String,String> map3 = new HashMap<>();
        map3.put("username","woniu");
        map3.put("password","1234565");
        map3.put("phone","188123456786");
        map3.put("address","chengdu");
//        System.out.println(map3.get("username"));

        List<Map> users = new ArrayList<>();
        users.add(map1);
        users.add(map2);
        users.add(map3);

        for (Map user : users){
            System.out.println(user.get("username"));
                System.out.printf("%s\t%s\t%s\n",user.get("username"),user.get("password"),user.get("phone"));
        }

运行结果如下: