学习基础1 认识软件+多态+面向对象+异常+枚举+泛型+集合

目录

软件：俗称程序。

数组 

方法

多态

​编辑

面向对象

抽象类：

异常：

枚举：Enum

泛型：

集合：

---

---

软件：俗称程序。

        系统软件：操作系统：windows

        应用软件：微信，王者.....

软件可以固化成硬件：例如：BOIS                                      软件是人开发出来的（编写出来的）

语言

开发语言： 汉语、英语：自然语言

高级语言：java（面向对象） C （面向过程：实时控制）php C++ C# pascal basic

中级语言：C

低级语言：机器语言、汇编(面向机器)

Java的构成：1：javaME（微型版）2：javaSE（标准版）3：javaEE（企业版）

JVM: java虚拟机

JRE: java运行环境

JDK:java开发工具

Java的执行步骤：

1：创建一个后缀为.java的代码文件

2：执行javac 进行编译，生成类名.class （字节码文件）

3：执行java 类名

注意：

1：对于java的代码文件（源程序）可以有多个class，但是只能有一个class声明为public的，且文件名称必须与声明为public的class同名！

2：class是java程序的最小单位。一个class会生成类.class

3：main方法是java程序的入口，且只能有一个

类的命名规范： (一个类就是一个功能)

1：类的命名一个都是名词：例如：Student User Person Dog Car

2:  首字母必须大写

封装

   为什么使用封装： 保护数据（1：不能随意的访问 2: 防止非法的数据）

   怎么实现封装：把属性（数据）进行私有化，并提供公共的get和set方法。

   封装的好处：代码可以重用，保证数据的安全性

Java中静态：static 有什么作用，目的是什么？（什么东西设计为静态的）

静态的东西是不会变的（圆周率等、太阳、地球）

区别	实例方法	静态方法
调用方式	必须通过对象	无需创建对象，直接通过类名.方法名
设计思路	更侧重于变化	更侧重于共性（不会变的）
生命周期	可以访问任何方法	只可以访问静态方法

记住：java中static的东西只执行一次，优先于对象的创建（对象创建之前）

静态方法只能调用静态的成员变量

关于匿名代码块和静态代码块构造方法的执行顺序

 

final

  修饰变量： final 数据类型 常量名（大写） = 值;

  修饰方法： 访问修饰符 final 返回类型 方法名(){}

       该方法可以被继承，不能被重写

  修饰类： final class 类名

       该类不能被继承

  修饰参数： 参数不能修改     

Java的数据类型：分为，基本数据类型和引用数据类型

基本数据类型：有8个，（保存在栈中，且内存固定）

整数类型：byte short int long

小数类型：float和double

字符类型：char

布尔类型：boolean

引用类型（保存在堆中，且内存不固定）

在java中为了节省内存和提高效率，一般把大小不固定的数据类型归为引用类型。

例如：String、数组、类、接口、集合等

区别	基本类型	引用类型
存放的内容	实际的值	值的地址
存放的位置	栈	堆

数组 

数组的定义：解决多个相同数据类型的变量的操作问题。

数组的特点：

1：内存中连续存放的（属于引用类型：因为大小不固定）                

2：通过索引（下标）进行操作

3：具有相同的数据类型。

数组的语法：

数据类型 [] 数组名 = {值,,,,}

数据类型 [] 数组名 = new 数据类型[int: 元素的个数]

数组的注意事项：

1：数组的声明和赋值不能拆开

2：数组的下标从0开始。

因为数组属于引用类型，所以当我们创建数组时，系统会给数组赋（默认）值：

方法

Java的方法按照参数和返回值来区分：

1：无参无返回值   void show(){}

2：无参有返回值   String show(){}

3：有参无返回值   void calc(int a,int b){}

4：有参有返回值   int calc(int a,int b){}

多态

多态的表现形式： 

1.参数是接口或父类

2.返回值是接口或父类

多态的实现机制：

1.抽象类

2.接口

区别	抽象类	接口
抽象层次	部分抽象	完全抽象
构造器	有	没有
多继承	没有	有
耦合度	高	低

面向对象

面向对象的核心：抽象

面向对象的中心思想：高内聚、低耦合、多聚合、少继承。

面向对象的设计原则：

1：单一职责：一个类只负责它自己的事情。（体现的高内聚）

2；开闭原则：Open Close （OCP）： 对扩展是开放，对修改是关闭。

3；里氏替换：父类出进行替现的地方总是可以使用子类换（父类引用指向子类对象）：多态

4：依赖倒置：编程时要依赖与抽象（抽象类或接口）进行编程，不要依赖与具体进行编程。

   （因为不变的是抽象，变化的是具体！）

5：接口隔离原则：接口最小化。（不要在一个接口中定义过多的不相关的方法）

6：迪米特法则：一个类对其它的类知道的越少越好。

抽象类：

抽象类是一个约束，需要有人来帮我们实现它

abstract：抽象 可以定义在类上，也可以定义在方法上。

有三大特点要记住：

1.不能new这个类，只能去用子类实现它，实现约束。

2.抽象类中可以写普通的方法。

3.抽象方法必须在抽象类中。 

（在定义抽象方法时，只有方法的名字，没有实现。

并且子类不一定必须实现它，子类也可以为抽象类，实现的则是子子类。）

抽象类在怎么样，也是一个类。只能单继承，只有接口可以多继承。

异常：

如何自定义异常（步骤） 

1：创建一个类继承Exception，并重写构造器。

public class MyException extends Exception{
    public MyException() {
        super();
    }

    public MyException(String message) {
        super(message);
    }

    public MyException(String message, Throwable cause) {
        super(message, cause);
    }

    public MyException(Throwable cause) {
        super(cause);
    }

    protected MyException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

    2：在方法上使用throws 自定义异常类

    3：在调用的方法上使用try catch

public class Demo1 {
    //throws :必须在方法上进行声明，且必须在throw进行抛出（给调用者）
    public int shuzu(int i)throws MyException{
        int m;
        int a[] = {1,2,3};
        try {
            m = a[i];
        }catch (Exception e){
            //注意这里的写法
            throw new MyException("超出");
        }
        return m;
    }
    public static void main(String[] args) {
        Demo1 ii = new Demo1();
        try {
            ii.shuzu(3);
        } catch (MyException e) {
            //e.getStackTrace();//打印的是堆栈消息
            System.out.println(e.getMessage());
        }
    }
}

  处理异常的目的：

1：解决程序的被迫中断（finally）

2：释放资源

异常的原则：

1：不要过多的滥用try会导致效率问题

2：能够通过判断解决的就不要使用try

枚举：Enum

1.固定的范围

2.在数组或集合中快速的找到所需要的值

枚举的应用：

Values：获取该枚举所有的值。

枚举的转换（String）

//String.valueOf(枚举)-->String
 String s1= String.valueOf(sex);
System.out.println(s1.equals("男"));
String s2="女";
//String转换为Enum，注意Enum.valueOf(这里是Class,后面是值)
Sex sex1 = Enum.valueOf(Sex.class,s2);
System.out.println(sex1);

枚举的作用：

1：通过限定用户的输入值的范围达到安全

2：效率高，快速的找到所需要的值。

枚举的本质：整型值的字面量。

泛型：

泛型的好处：

1：安全：进行了语法的检查

2：效率：无需进行类型转换

泛型指的是参数的类型是广泛的（使用的时候由用户来决定数据类型）

注意事项：参数的类型必须是引用类型不能是基本类型

Java的泛型包括三个：

1：泛型类

//泛型的目的：
//        1：效率高：无需类型转换
//        2：安全：进行了语法检查
//        泛型的注意事项：泛型的参数必须是引用类型不能是基本类型<引用类型>

//泛型类：确保参数是个通用的（由用户来决定参数是数据类型）
public class Point <E>{
    private E x;

    public E getX() {
        return x;
    }

    public void setX(E x) {
        this.x = x;
    }

    public static void main(String[] args) {
        Point <Float> p1 = new Point<Float>();
        p1.setX(3.14f);
        Point <Integer> p2 = new Point<Integer>();
        p2.setX(123);
    }
}

2：泛型方法

//泛型方法 达到代码的通用性的目的。
public class User {
    //判断参数的类型
    public <T> void call(T t1,T t2){
        //instanceof判断左边对象是否是右边类
        if (t1 instanceof Integer && t2 instanceof Integer){
            System.out.println("执行Integer的操作");
        //intValue()是把Integer对象类型变成int的基础数据类型
            System.out.println(((Integer) t1).intValue()+((Integer) t2).intValue());
        }else if (t1 instanceof String && t2 instanceof String){
            System.out.println("执行了String的操作");
            System.out.println(Integer.parseInt(t1.toString())+Integer.parseInt(t2.toString()));
        }else if (t1 instanceof Float && t2 instanceof Float){
            System.out.println("float.......");
            System.out.println(((Float) t1).floatValue()+((Float) t2).floatValue());
        }
    }

    public static void main(String[] args) {
        User user = new User();
        user.call(new Integer(3),new Integer(5));
        user.call("23","11");
        user.call(2.5f,3.6f);
    }

}

3：泛型接口

//泛型接口
public interface IDao <T> {
    List<T> findAll();
    int add(T t);
}

泛型的高级应用（确保代码的正确性等）

? extends 类 ：指定上边界

? Super 类： 指定下边界

集合：

集合的定义：类似与数组（进行不同数据类型的操作：添加、查询、删除、迭代等）

集合的作用：集合可以对不同数据类型进行处理，且不用考虑容器大小。

集合的构成：

接口：List(特点：通过索引、可以有重复值) ， set（特点：没有索引，不能重复）， Map

实现类：ArrayList

算法： Collections

集合的用法

接口的作用：

1：封装变化：接口中定义操作（方法），由各个实现类进行方法的重写。

   接口是不会变化的，变化的是实现类。

2：身份的象征

public class Demo1 {

    public static void main(String[] args) {
        Collection<Integer> collection =
                new ArrayList<Integer>();
        List list= new ArrayList<>();
        //接口                 实现类
        list.add(true);  // 0
        list.add(345);   // 1
        list.add('d');   // 2
        list.add("hello"); //3
        list.add(43.353f);// 4

        System.out.println(list);//所有的集合的实现类都已经重写了toString方法，不在打印对象的地址，而是直接输出该集合中的元素
        System.out.println("集合的元素的数量（个数）"+list.size());
        for(Object obj: list){
            System.out.println(obj);//会自动进行类型转换
        }
        //获取某个集合中的元素：通过索引
        System.out.println(list.get(2));// d
        //删除
        //list.remove(2);//通过索引进行
        //list.remove('d');//有问题，不能进行删除，因为没有使用泛型，默认转换为int a:97 98 99 100
        //System.out.println("删除索引为2的后："+list);


    }
}

  迭代：每次循环都会对下一次循环造成影响。

  遍历：从头到尾输出。

//只可以实现一种排序（默认）规则   ，如何实现对类的不同 的属性分别实现排序呢？

//Java提供java.util.Comparator<User>作为补充

public class AgeSort implements java.util.Comparator<User> {
    @Override
    public int compare(User o1, User o2) {
        if(o1.getAge()>o2.getAge()) return  1;
        else if(o1.getAge() < o2.getAge()) return -1;
        return 0;
    }
}
public class NameSort implements java.util.Comparator<User> {
    @Override
    public int compare(User o1, User o2) {
        //根据name进行排序的规则的实现
        return o1.getName().compareTo(o2.getName());
    }
}
public class NameSort implements java.util.Comparator<User> {
    @Override
    public int compare(User o1, User o2) {
        //根据name进行排序的规则的实现
       // return o1.getName().compareTo(o2.getName());
        //处理中文： Text 文本 区域： Locales
        return   java.text.Collator.getInstance( Locale.CHINESE).compare(o1.getName(), o2.getName());
    }
}

ArrayList和Vector的区别

ArrayList: 异步的实现

特点：动态数组、添加时会自动增长、删除时会自动收缩！（倍增器）

 提高效率：强烈推荐创建时分配一个容量
List<> list=new ArrayList<>(容量);

异步和同步的区别

区别	异步 arraylist(hashmap)	同步 vector (hashtable)
效率	高	低
数据的一致性	不能保证：不安全的	可以保证：安全的

List（擅长做遍历：最不擅长做插入和删除操作，通过索引、可以有重复值）

Set接口（没有索引，无序、不重复：HashSet  TreeSet (添加自定义的类必须实现java.lang.Comparalbe)）

Map（地图：查询 擅长做查询）

Map通过key和value 键值对（例如：通讯录）

一个key可对应多个值：hashmap（异步的） 和hashtable（同步的）

注意事项：Hashmap可以存放nulll，但是只能存放一个null；

import static com.sun.org.apache.xml.internal.security.keys.keyresolver.KeyResolver.iterator;

public class MapDemo {
    public static void main(String[] args) {
        Map<String,Object> map=new HashMap<String,Object>(5);
        map.put("cn", "China");
        map.put("cn", "China");
        map.put("us", "American");
        map.put("rs", "Russia");
        System.out.println(map);
        System.out.println(map.get("cn"));
        map.remove("us");
        map.put(null, null);
        System.out.println(map);
        System.out.println("判断是否存在key值："+map.containsKey("cn"));
        //迭代map： map没有迭代器 ，必须通过key和values分别得到迭代器。
        //map.keySet();// map的key本身是个set集合
        //map.values();//map的value本身是个Collection集合
        System.out.println("迭代key");
        for(Iterator<String> key= map.keySet().iterator(); key.hasNext();){
            System.out.println(key.next());
        }
        System.out.println("迭代value");
        for(Iterator<Object> value=map.values().iterator();value.hasNext();){
            System.out.println(value.next());
        }
        System.out.println("获取key-value");
        //Map.Entry<String,Object> entry=map.entrySet();
        Set<Map.Entry<String, Object>> entries = map.entrySet();
        Iterator<Map.Entry<String, Object>> iterator = entries.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}