文章首页 Web开发 Windows开发 编程语言 数据库技术 移动平台 系统服务 微信 设计 布布扣 其他

java基础知识点

时间：2020-08-23 10:12:52   收藏：0   阅读：65
1.Java基础语法
Java的类要满足java规范，有包，有无参构造器，实现序列化接口 
外部类类修饰符：public、default、abstract、final、strictfp（final和abstract不能一起用，因为abstract抽象类必须被继承，而final修饰的类不能被继承）（外部类不能用private和protected）
接口修饰符    ：public、default、abstract(接口本就是抽象，加不加一样)、strictfp   接口的方法：public  abstract  接口的常量： public static final (接口默认的就是abstract类型)
构造器修饰符  ：public、protected、default、private 
全局变量修饰符：public、protected、default、private、static、transient（不序列化）、final、 volatile(同时被几个线程控制修改)
局部变量修饰符：final
方法修饰符    : public、protected、default、private、abstract、static、final、synchronized、strictfp
成员内部类  ：public、protected、default、private、static、abstract、final、strictfp（声明成static就是静态内部类了）
方法内部类：default  abstract strictfp final  作用域只在该方法中
 
 
protected修饰的变量、方法、构造器的使用：包内和子类可见
确定出该protected成员来自何方，其可见性范围是什么？ object的clone()就是这种protected方法。
1.父类的protected成员是包内可见的，并且对子类可见；（总结就是该protected来自哪里，只能在该本包或者子类中使用，调用该方法的地方是否合适）
1.1 同一个包：可以任意使用
1.2 不同包：不能通过实例化父类或其它子类来访问父类的protected成员
  1. 变量名命名：不以数字开头，驼峰命名：单词开头小写，后续单词首字母大写
  2. 全局变量可以自动初始化，局部变量使用前必须自己初始化。
  3. 运算符、转型、结构语法，
  1. 类
  1. 类：成员变量、成员方法。
  2. 修饰符：
private：本类
默认:本包
protected:本包和子类
public:所有都可以访问
  1. 重载overload：方法名相同，参数（个数，顺序，类型）不同，返回值随意，编译期绑定。
  2. 重写override：子类的返回类型(相同或者是父类返回值类型的子类)、方法名、参数都相同，访问权限只大不小。运行期绑定。
  3. 构造方法：用于初始化对象。程序会给没有构造方法的类构造一个默认无参的构造方法，如果类定义了构造方法，就不会有默认的构造方法。
  4. 构造器 Constructor 不能被继承，
  5. this:
    代表本类的一个对象,在非静态方法中会传入一个this引用进去，this.name  this.method()
    构造方法也可以用this引用本类的另一个构造方法。在构造方法第一句使用
  6. 继承(单继承)
  7. extends:父类的变量和方法，但是继承父类private的成员变量和方法是不可见的，不能在子类中使用，因为private的成员只能在本类中可见。
  8. super：父类的对象
  9. 子类的构造方法中会先调用父类的构造方法，子类的构造方法中第一行用super(。。)调用父类的构造方法。没写默认调用父类无参构造方法
  10. 子类不是继承但有和父类相同的变量或方法，这是隐藏父类的成员导致的。是子类自己的。
  11. static
  12. static方法没有隐士this    实例方法有this参数，所以static方法不能直接使用非static成员，也不能使用this、super关键字，用类名.成员使用。
  13. static{}块  在类的加载的时候初始化，static块为属于类的代码块，在类加载期间执行的代码块，可以有多个块，只执行一次，可以用来在软件中加载静态资源（图像、音频等等）。
  14. static方法不能被重写，jvm认定了static是属于类的，子类再写相同的方法名那是隐藏而已。
  15. 实例方法可以访问类变量，static可以通过对象调用，一般是直接类名.属性
  16. final
  17. 修饰成员变量：声明同时初始化或者构造方法中初始化，初始化一次，不可更改。
  18. 修饰局部变量：使用之前初始化就可。
  19. 修饰的引用变量：只是表示变量指向的地址不会变，但引用对象的内部数据可变的。
  20. final引用指向对象，表示这个引用只能指向这个对象， 但是这个对象本身内部数据是可以更改的。要使其变成不可更改，使用static final
  21. 修饰方法:不能被重写
  22. 修饰类：不能被继承，
  23. static final 修饰的成员变量称为常量，必须声明同时初始化，并且不可被改变。大写（编译期间执行）
  24. volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
  25. 抽象类
  26. Abstract class类名{}方法中的方法是abstract方法：abstract 返回值 方法名（）;
  27. 抽象类不能实例化，需要被子类继承，可以用构造方法，只是不能实例化，可以在子类调用super()
  28. 抽象方法是修饰不能是private，也不能是final
  29. 定义抽象类的意义在于：
为其子类提供一个公共的类型（父类引用指向子类对象）；
封装子类中的重复内容（成员变量和方法）;
定义有抽象方法，子类虽然有不同的实现，但该方法的定义是一致的。(子  类需要实现此抽象方法)。
  1. 接口（要实现接口但是只用一次的使用匿名内部类）
  1. 形式：Interface 类名{}   不能被实例化，没有构造函数，没有静态代码块，可以声明变量
  2. 接口里面的变量都是public static final (可以省略)，方法都是 public abstract的抽象方法（可以省略）
  3. 类实现多个接口：a implements 接口1,接口2;实现接口里面的所有方法。并且子类里面的方法必须是public
  4. 接口可以继承多个接口，a extends b,c
  5. 一个类先继承再实现
  6. jdk8接口中新增的默认方法和静态方法
默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。
静态方法：使用 static 修饰，静态与.class 文件相关，不能被子类继承，不能被子类重写，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用，接口.方法名()调用。
私有方法：
    私有方法：只有默认方法可以调用。
    私有静态方法：默认方法和静态方法可以调用。
public interface InterFaceName {
public default void method() {
// 执行语句
}
public static void method2() {
// 执行语句
}
private void func1(){
System.out.println("私有方法");
}
private static void func2(){
System.out.println("私有静态方法");
}
 
默认方法：子类实现接口之后可以直接调用，也可以自己重写。
public class Son implements InterFacename{
@Override
public void method() {
System.out.println("重写默认方法");
}
}
 
静态方法的使用
public interface LiveAble {
public static void run(){
System.out.println("跑起来~~~");
}}
public class Animal implements LiveAble {
// 无法重写静态方法
}
public class InterfaceDemo {
public static void main(String[] args) {
// Animal.run(); // 【错误】无法继承方法,也无法调用
LiveAble.run(); //
}
 
注意：
1.类实现多个接口，这几个接口有相同的默认方法，类必须重写一次，静态方法不用，因为静态方法只有各自接口名访问。
2.当类继承另一个类B并实现了一个接口，这个接口的默认方法和类B有相同方法，子类就近选择执行父类的方法。 
3.子类重写接口的默认方法，default关键字不能保留，子接口继承接口，要重写父接口的默认方法，可以保留关键字。
  1. 多态（Person p = new Son();）
  1. 父类的引用指向子类的对象(方法指的是父类拥有的方法，具体看子类的实现，不包括子类自定义拥有的方法，只能看到继承父类的那些方法，有重写的方法执行的是子类重写的方法。)
  2. 多态实现的条件：
  1. 继承或者实现
  2. 重写方法
  3. 向上造型
  1. 向上造型
  1. 父类（或接口）的引用指向子类对象Son son = new Son();Fateher f = son或Fateher f =new Son();
  1. 向下转型(强转)
  1. instanceof用法:if(f instanceof Son)   son=（Son）f;  
  1. 还可以通过强制转换将父类型变量转换为子类型变量，前提是该变量指向的对象确实是该子类类型(父子)。也可通过强制转换将变量转换为某种接口类型，前提是该变量指向的对象确实实现了该接口(接口-实现类)。如果在强制转换过程中出现违背上述两个前提，将会抛出ClassCastException
  1. 内部类
    在非静态内部类中不可以声明静态成员
  2.  成员内部类
  3. 作为外部类的成员存在，是一个独立的类，再编译之后内部类会被编译成 外部类$内部类.class
  4. 内部类有一个隐士this指向外部类，所以内部类可以访问外部类的所有包括私有的变量和方法，外部类访问内部类需要先实例化内部类
  5. 再外部类里面或者外部类的非静态方法中可以直接实例化内部类，在其他类或者静态方法中需要先实例化外部类，如 Outer.Inter inter = new Outer() .new Inter();
java初始化顺序：
  1. 静态对象-非静态对象-构造器 
    其中静态对象包括：静态块，静态方法，静态属性
  2. 对于继承父类的对象的初始化顺序：父类静态对象-子类静态对象-父类构造方法-子类构造方法 
    说明：在静态对象中初始话顺序实际上是按照声明的顺序执行的。
  3. 局部内部类
  4. 在方法体、构造方法中的内部类
  5. 只能在方法体中实例化，该类的方法形参必须用final修饰。
  6. 内部类可以使用外部类的所有成员变量和方法
不能有访问修饰符，正如它就像方法体中的局部变量，可以有final abstaract修饰。
  1. 静态内部类（成员内部类加上static就是这）
  2. 没有外部类的引用传进来，其他都一样
  3. 可以定义成public、protected、默认的、private等多种类型
  4. Outer.Inter 引用名=new Outer.Inter();
  5. 不能访问外部类的非静态成员，可以直接引用外部类的static的成员变量，不需要加上外部类的名字。
  6. 匿名内部类
  7. 匿名内部类能继承一个类或者实现一个接口（二者取其一），其实现过程一样的是先继承或者实现接口或类，然后用向上转型，把实例对象赋值给接口或者父类。
 interface MyInterface { //接口中方法没有方法体 void test(); }
new MyInterface(）  {
            public void test()  {
                System.out.println("匿名实现MyInterface接口");
                System.out.println(temp);  } }
 
 

原文：https://www.cnblogs.com/zhouyanger/p/13548173.html

评论（0）
© 2014 bubuko.com 版权所有 - 联系我们:wmxa8@hotmail.com
打开技术之扣，分享程序人生！