Java知识点总结

第一章：入门

java特点：面向对象，两个基本概念：类、对象，三大特性：封装、继承、多态

java工作方式：1、编写源程序 2、编译源程序 3、运行

Java程序的结构：如果源文件包含一个public类，则文件名必须按该类名命名

第二章：语法基础

引用数据类型变量作为参数则是按引用传递的，包括类，接口和数组

变量的命名规则：首字符：1、字母 2、下划线‘_’ 3、‘$’ 符号

​ 其余部分：任意多的：1、数字 2、字母 3、下划线‘_’ 4、‘$’ 符号

在Java语言中，boolean类型只有“true”和“false”两个值

&和|会将式子两边的运算式都进行运算，但&&会在左边未满足时直接跳过，||会在左边满足时直接跳过

Java 语言中除了单目运算符、赋值运算符和三目运算符是从右向左结合之外，其他运算符均是从左向右结合

数组的声明，分配空间和赋值

int []a;
a=new int[5];
int[] a=new int[5];//可以合一起
int[] score=new int[]{89,79,76}; //不能声明数组长度

//二维数组
int mat[][] = new int [3][4]; 
int [][] mat = new int [3][];
int mat[][] = { {1,2,3},{4,5,6} };

第三章：类的初步认识

方法之间允许相互调用

第四章：构造函数和函数的重载

只有构造函数才能调用构造函数

第五章：静态和代码块

静态变量

static是一个修饰符，用于修饰成员

static优先于对象存在，因为static的成员随着类的加载就已经存在

静态变量数据存储在方法区的静态区，故亦称对象的共享数据

静态函数

静态代码块

只在类加载时运行一次，且优先于各种其他代码块以及构造函数

静态代码块不能访问普通变量

构造代码块

创建对象时被调用，每次创建时都会被调用

依托于类构造函数，优先于类构造函数执行

存在多个构造代码块，则按书写顺序依次执行

和构造函数的作用类似，通常用于对对象进行初始化，且只要创建对象，构造代码块都会执行一次

构造函数则不一定每个对象建立时都执行

执行顺序：
静态代码块 > 构造代码块 > 构造函数 > 普通代码块

第六章：包和类中类

1.包的创建

package com.hz.classandobject;//若有包的声明，一定作为Java源代码的第一条语句
//包名由小写字母组成，不能以圆点开头或结尾

2.包的使用

package org.it315;   //声明包
import org.it315.example.*; //导入包中的所有类
import org.it315.example.Test;//导入包中的指定类
public class TestPackage{
    public static void main(String[] args){
       new Test().print();
    }
}

如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句

如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入

3.访问控制修饰符

4.类中类(我为什么觉得类中类没那么重要)

(1)成员内部类

成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）

外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问

class Outter {
    private Inner inner = null;
    public Outter() { ... ... }     
    public Inner getInnerInstance() {
        if(inner == null)
            inner = new Inner();
        return inner;
    }      
    class Inner {
        public Inner() { ... ... }          
    }
}

public class Test {
    public static void main(String[] args)  {
        //第一种方式：
        Outter outter = new Outter();
        Outter.Inner inner = outter.new Inner(); 
         
        //第二种方式：
        Outter.Inner inner1 = outter.getInnerInstance();
    }
}

内部类可以拥有private、protected、public及包访问权限。

(2)局部内部类

定义在方法或作用域内的类，仅限方法或该作用域内访问

class People{
    public People() { ... ... }
} 

class Man{
    public Man(){ ... ... } 
    public People getWoman(){
        class Woman extends People{   
            int age =0;
        }
        return new Woman();
    }
}

(3)匿名内部类

匿名内部类也就是没有名字的内部类。

abstract class Person {
    public abstract void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

匿名内部类不能定义任何静态成员、方法；
匿名内部类中的方法不能是抽象的；
匿名内部类必须实现接口或抽象父类的所有抽象方法；
匿名内部类没有类名，因此不能定义构造器；java
当匿名内部类和外部类有同名变量（方法）时，默认访问的是匿名内部类的变量（方法），要访问外部类的变量（方法）则需要加上外部类的类名。

(4)静态内部类

由static关键字修饰的内部类。

public class Person{    
     private String name; //姓名   
     private Home home; //家庭   
    
     public static class Home{    
          private String address; //家庭地址   
          private String tel; //家庭电话   
     }    
} 

public static void main(String[] args) {    
    Home home = new Person.Home("上海", "021");  
    Person p1 = new Person("张三");    
    Person p2 = new Person("李四");    
    p1.setHome(home);    
    p2.setHome(home);    
    //创建一个静态内部类home对象，p1和p2共享同一个home对象
} 

类似于静态成员变量，静态内部类是不需要依赖于外部类；
可定义匿名代码块、静态代码块、静态或非静态成员；
不能在静态内部类中写抽象方法
静态内部类可以直接调用外部类的静态成员，也可通过创建外部类实例的方式调用外部类的非静态成员

(5)作用

public interface InnerInterface {
      void innerMethod();
}
  
class OuterClass {
    private class InnerClass implements InnerInterface {
        public void innerMethod() {
            System.out.println(“实现内部类隐藏");
        }
    }      
    public InnerInterface getInner() {
        return new InnerClass();
    }      
}

public class Test {
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        InnerInterface inner = outerClass.getInner();
        inner.innerMethod();
    }
}
//仅能知道OuterClass的getInner()能返回一个InnerInterface接口实例却无从知晓其实现方式；同时由于InnerClass是私有的，因此，连其具体类名都隐藏了起来。
                               
public class Parents1 {
      public String name(){
            return “inner”;
      }
}
public class Parents2 {
      public int age(){
            return 18;
      }
}   
Public class Test {
    private class Inner1 extends Parents1 {
        ... ...
    }      
    private class Inner2 extends Parents2 {
        ... ...
    }      
}
//通过两个内部类间接实现了Test类对Parents1和Parents2的多重继承
                               
public class DemoTest extends MyDemo {
      private class inner implements Demo {
          public void test() {
              System.out.println("接口的test方法");
          }
      }      
      public Demo getIn() {
          return new inner();
      }     
      public static void main(String[] args) {
          DemoTest dt = new DemoTest();
          Demo d = dt.getIn();
          d.test();//调用接口而来的test( )方法        
          dt.test();//调用继承而来的test( )方法
      }
}

第七章：继承

Java类的继承结构为树状结构（即层次结构），Java系统类库中的java.lang.Object类为整个树状结构类图的、最顶层的树根节点

同名属性不能覆盖，只会在子类中增加新的属性

继承后的初始化顺序： 父类属性 \(\rightarrow\) 父类构造函数 \(\rightarrow\) 子类属性 \(\rightarrow\) 子类构造函数

在Java类中使用super关键字来调用父类中的指定操作，super可用于在子类构造函数中调用父类的构造函数，当子父类出现同名成员时，可用super表明调用的是父类成员

子类将先执行继承自父类的无参数构造函数，然后再执行自己的构造函数

在有参数构造函数中首行必须用super(参数)语句，实现对基类数据成员初始化的任务

重写

在子类中可以根据需要对从父类中继承来的方法的实现过程进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

保持与父类完全相同的方法头部声明，即应与父亲有完全相同的方法名和参数列表

子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限

声明为private和final的方法不能被重写

声明为 static 的方法不能被重写，但可被再次声明

第八章：多态

1.JAVA中的多态性

编译时多态：主要指方法的重载，它根据参数列表的不同来区分不同的方法。通过编译后变成不同的方法。

运行时多态：即动态绑定，指在执行期间（非编译期间）判断引用对象的实际类型，根据实际类型判断并调用相应的属性和方法。主要用于继承父类和实现接口时，父类引用指向子类对象

多态存在的三个必要条件：继承，重写，父类引用指向子类对象

当使用多态方式调用方法时，首先检查父类中是否有该方法，若无，则编译错误；若有，则调用父类同名同参数的方法，但实际执行的是子类重写父类方法，称为虚拟方法调用

静态方法并不具有多态性

2.多态的转型

向上转型：父类类型 变量名 = new 子类类型();

向下转型：子类类型 变量名 =（子类类型） 父类类型的变量;（一般用于需要使用子类特有功能时）

class Fruit{
    public void myName(){
        System.out.println("我是父类  水果...");
    }
}

class Apple extends Fruit{
    public void myName(){
        System.out.println("我是子类  苹果...");
    }
    public void myMore(){
        System.out.println("我是你的小呀小苹果~~~~~~");
    }
}

public class Test{
    public static void main(String[] args) {
        Fruit a=new Apple();//向上转型
        a.myName();
        Apple aa=(Apple)a;//强制转换时要保证父类变量是对子类对象的引用
        aa.myName();
        aa.myMore();//子类的特有功能
        Fruit f=new Fruit();
        Apple aaa=(Apple)f;//这就不行，编译通过，但是运行会报错
        aaa.myName();
        aaa.myMore();
        
        if(f instanceof Apple){//对象x instanceof 类A，判断某个对象是否属于某种数据类型
    	Apple aaa=(Apple)f; 
    	aaa.myName();
    	aaa.myMore(); 
		}
    }
}

第九章：抽象类，final和接口

1.抽象类

定义：类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类

用abstract关键字来修饰一个类，这个类叫抽象类，用abstract来修饰一个方法，该方法叫抽象方法。

public abstract class Shape {
    public int width; // 几何图形的长
    public int height; // 几何图形的宽

    public Shape(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public abstract double area(); // 定义抽象方法，计算面积
}

拥有一个抽象方法并不是构建一个抽象类充分必要条件

抽象和私有是冲突的，抽象和静态是冲突的，抽象和final也是如此

抽象类可以有构造函数，初始化抽象类的成员，但构造函数不可用abstract修饰。

abstract也不可用来修饰变量、代码块。

2.final

final标记的类不能被继承 - String类、System类、StringBuffer类

final标记的方法不能被子类重写 - 比如：Object类中的getClass()

final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次，必须在定义时或者构造器中进行初始化赋值

final修饰局部变量 ，则该变量变成了常量

final修饰方法的形式参数 ，则该形参数在方法中不能修改，是常量

static final修饰属性：全局常量

对于一个final变量，如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象，但是它指向的对象的内容是可变的。

当final变量是基本数据类型以及String类型时，如果在编译期间能知道它的确切值，则编译器会把它当做编译期常量使用

static作用于成员变量用来表示只保存一份副本，而final的作用是用来保证变量不可变（和c++中const相似）

3.接口

本栏目推荐文章
• 深入探索JVM：理解Java程序在虚拟机中的存储和管理
• 用jacoco统计JAVA项目测试代码覆盖率
• Java实现在线编辑预览office文档
• Java小细节之缩进中if 和else的对应关系
• 春眠不觉晓，Java数据类型知多少？基础牢不牢看完本文就有数了
• idea 中java代码修改后运行代码不生效
• Java日期时间处理详解
• java项目(jar包)配置为开机自启 jar包bat脚本启动和配置为开机自启
• Java中锁的解决方案
• Java学习之路1

知识点 知识 Java知识java 知识点 知识java 基础知识 基础 知识java 图谱 体系 知识java 知识点 知识java sir 基本知识 知识first java java工程师 精华 知识 常用 知识java tips 不断 知识java 体系 知识java