java基础知识笔记（基础语法+面向对象编程思想）

java基础知识笔记（基础语法+面向对象编程思想）

【第一部分：java基础语法】

一、java概述

java8公司用的多。

跨平台原理（JVM）

JDK>JRE>JVM

下载JDK即可：http://www.oracle.com

JDK文件目录：

二、第一个程序

三、基础语法

计算机存储单位（一个大B是一个字节，等于8个小b）：

a joke：字节跳动是大B跳动，等于8个小b跳动。

数据类型：

 

（放栈里）基本数据类型的值+引用类型

（放堆里）引用数据类型的内容。

8个基本数据类型：

变量使用的注意事项：

命名规范：

类型转换：

（1）自动类型转换（小到大）：

（2）强制类型转换（大到小）

四、运算符

类型提升（碰到大的提升为大的）：

逻辑运算符：

短路逻辑运算符：

五、数据输入

六、分支语句

switch语句：

                           

七、循环语句

1.for循环语句

2.while循环语句

3.do while循环语句

4.Random（获取随机数）

八、IDEA

1.IDEA概述与安装

https://www.jetbrains.com/idea/

2.创建项目

3.IDEA中项目结构：

项目>模块（统一功能的文件夹）>包（javaoffer.dalaoxin）>类（class，一个类就是一个java文件）

（1）包与包之间：

访问类，需要导包；包与包之间访问类的成员，需要pulic。

（2）包以下（package声明）：

类访问，则都不需要。

4.IDEA中：内容辅助键+快捷键

 

九、数组

（1）动态初始化

（2）静态初始化

 

十、方法

形参、实参：

Debug：

设立断点；按F7进入到下一步；点stop结束。

十三、面向对象基础

类和对象:

类和对象包括：属性+方法

实现封装--->>private关键字:

this关键字:

成员变量和局部变量同名冲突时候，用this访问成员变量，否则会默认访问局部变量。

标准类制作：

//标准类的制作
public class Student {
    //成员变量用private修饰
    private String name;
    private int age;

    //构造方法:一个无参方法，一个多参构造方法
    public Student(){}
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }

    //成员方法
    public void setName(String n){
        this.name=n;
    }
    public String getName(){
        return name;
    }
    public void setAge(int a){
        this.age=a;
    }
    public int getAge(){
        return age;
    }

    public void show(){
        System.out.println(name+","+age);
    }

}

十四、字符串相关

String：

输入一个字符串然后遍历：

import java.util.Scanner;

public class StringPlay{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个字符");
        String line=sc.nextLine();
        for(int i =0;i<line.length();i++){
            System.out.println(line.charAt(i));
        }
    }
}

拼接（加法）操作：

jdk1.8之后字符串拼接底层就是创建了一个StringBuilder，然后调用append方法，最后调用toString转化成String。（在堆中会开出多余的内存）

StringBuilder:

(1)StringBuilder相对于String的优势（不会在堆中开辟新的空间，直接在原空间上改变）：

append()、reverse()

(2)StringBuilder和String相互转换：

 

 

【第二部分：类和对象思想】

一、继承

 

 

1.继承中变量的访问：

2.继承中成员方法的访问特点：

3.this和super

4.继承中构造方法的访问特点：

子类中所有构造方法都会默认访问父类的无参构造方法。

5.方法重写：

子类中出现和父类一样的方法声明，就需要方法重写。

注意事项：

7.继承的注意事项：

（1）单一继承

（2）多层继承

二、修饰符

1.权限修饰符

2.状态修饰符

（1）final

（2）static

访问特点：

静态只能访问静态，不能访问非静态。

三、多态

1.什么是多态？

2.多态中成员的访问特点：

 Animal a=new Cat();

3.多态的好处和弊端：

4.多态中的转型:

向上转型、向下转型示例：

四、抽象类

1.抽象类定义

只声明，不给出具体定义。（Abstract）

2.抽象类特点：

3.抽象类的成员特点：

五.接口：

1.接口的特点：

2.抽象类和接口的关系：

七、内部类

内部类的访问特点：

八、常用API

1.Math类常用方法：

2.System类常用方法：

3.Object类：

十、集合

1.泛型:

（1）泛型类：

（2）泛型方法：

（3）泛型接口：

（4）类型通配符：

2.可变参数：

3.List接口：

ArrayList:

 

add(),remove(),set(),get(),size().

4.Map接口:

Map是个接口，不能发直接创建对象；可以通过HashMap实现类实现。

（1）Map集合的方法：

基本功能：entrySet(),keySet(),getKey(),getValue()

获取功能：

（2）实例化，面向接口编程：

Map<String,String> map=new HashMap<String,String>();
//Map<String,String> student=new HashMap<>(){{put("001","夏志新");put("002","王发润");}};
map.put("001","夏志新");
map.put("002","王发润");
System.out.println(map);

（3）Map集合的遍历：

方式1：

用.keySet()方法得到集合，然后访问集合

Set<String> keyset=map.keySet();
for(String key:keyset){
   String value=map.get(key);
   System.out.println(key+"fuck"+value);
}

方式2：

用entrySet()获取所有键值对对象,类型为Map.Entry<String,String>

Set<Map.Entry<String,String>> entrySet =map.entrySet();
for(Map.Entry<String,String> me:entrySet){
    String key=me.getKey();
    String value=me.getValue();
    System.out.println(key+"fuck"+value);
}

5.异常

（1）try{}catch(){}finally{}

找到异常后，程序回继续往下运行，输出“结束”。

public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
    }

    public static void method() {
        try{
        int[] arr = {1, 2, 3};
        System.out.println(arr[3]);
        }catch (ArrayIndexOutOfBoundsException e){
           System.out.println("您访问的数组索引不存在");
           e.printStackTrace();
        }
    }
}

（2）方法 throws 异常类名{}

编译时异常，运行时异常。

6.增强for循环:

回顾三种遍历方式：

十一、IO流

1.File

创建功能：

判断和获取功能：

删除功能：

2.字节流和字符流的区别？

3.字节流

（1）创建字节流输出对象：

FileOutputStream fos=new FileOutputStream("src/fox.txt");

（2）字节流写数据：

（3）字节流小节

4.字符流

字符流小结：

5.特殊操作流

十二、多线程

进程：正在运行的程序。

线程：进程中的单个顺序控制流。java虚拟机允许java程序同事执行多个线程。

1.实现多线程

（1）方式1：继承Thread类

多个对象执行，此时会同时执行，就是多线程执行。

重写的run()方法就是用来存放方法的执行内容，多线程时使用start()

class MyThread extends Thread{
    public MyThread(){}
    public MyThread(String name){
        super(name);
    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(getName()+i);
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread my1=new MyThread("高铁");
        MyThread my2=new MyThread("飞机");
        MyThread my3=new MyThread("汽车");
//        my1.setPriority(5);
//        my2.setPriority(10);
//        my3.setPriority(1);
//        my1.run();
//        my2.run();
        my1.start();
        my2.start();
        my3.start();
    }
}

（2）方式二：实现Runnable接口：

class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+""+i);
        }
    }
}

public class RunnableDemo {
    public static void main(String[] args) {
        MyRunnable my=new MyRunnable();
        Thread t1=new Thread(my,"高铁");
        Thread t2=new Thread(my,"飞机");
        t1.start();
        t2.start();
    }
}

好处：

2.线程调度，线程优先级：

setPriority()方法：设置线程优先级。

3.线程控制：

sleep()：每执行一次（run方法中的代码），线程就休息一会。在类的run方法中写。

join()：此线程死亡，别的线程才能开启。在优先的那个实例上写。

setDaemon()：将线程设置为守护线程（守护线程，也是写在实例），主线程执行完毕，则java虚拟机退出。

Thread.currentThread()：获取当前线程

4.线程的生命周期：

5.同步代码块：

数据安全问题的特征：

线程同步解决数据安全问题：

6.同步方法：

 

7.线程安全的类：

8.Lock锁（接口）

9.生产者和消费者模式

多线程协作的模式：

十三、网络编程

1.网络通信三要素：

2.IP地址

、

InetAddress类：

3.端口

4.协议

5.UDP协议：

UDP发送数据:

public class SendDemo {
    public static void main(String[] args) throws IOException {
        DatagramSocket ds=new DatagramSocket();
        byte[] bys="hello，udp，我来了".getBytes();
        DatagramPacket dp=new DatagramPacket(bys,bys.length, InetAddress.getByName("192.168.119.1"),10086);
        ds.send(dp);
        ds.close();
    }
}

UDP接收数据:

public class RecieveDemo {
    public static void main(String[] args) throws IOException {
        DatagramSocket ds=new DatagramSocket(10086);
        byte[] bys=new byte[1024];
        DatagramPacket dp=new DatagramPacket(bys,bys.length);
        ds.receive(dp);
        byte[] datas=dp.getData();
        String dataString=new String(datas);
        System.out.println("接收的数据是"+dataString);
        ds.close();
    }
}

6.TCP：

TCP发送数据：

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        Socket s=new Socket("192.168.119.1",10000);
        OutputStream os=s.getOutputStream();
        os.write("hello,tcp,我来了".getBytes());
        s.close();
    }
}

TCP接收数据：

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        ServerSocket ss=new ServerSocket(10000);
        Socket s= ss.accept();

        InputStream is=s.getInputStream();
        byte[] bys=new byte[1024];
        int len=is.read(bys);
        String data=new String(bys,0,len);
        System.out.println("服务器:"+data);

        OutputStream os=s.getOutputStream();
        os.write("数据已经收到".getBytes());
        ss.close();
    }
}

十四、Lambda表达式

十五、接口组成更新

1.接口的默认方法：

接口和实现类的关系：实现类需要套将接口中所有的方法全部重写。(除了默认方法不用重写)

主要用来实现接口的升级。

public viod default...

2.接口中的静态方法：

十六、方法引用

十七、函数式接口

十八、Stream流

十九、反射

1.反射机制概述:

动态语言：运行时代码根据某些条件改变自身结构，如Python、JavaScript。

静态语言：运行时结构不能变得语言，Java。但Java可以通过反射机制达运行时改变得目的，因此可以称为“准动态语言”。

2.理解Class类并获得Class实例：

Class类：

Class类得获得方式：

Class类得常用方法：

3.类的加载与ClassLoader：

4.创建运行时类的对象：

5.获取运行时类的完整结构：

6.调用运行时类的指定结构：