java基础<基础知识整理>

对象的初始化过程

一、对象进行new以后的内存发生了那些事情

对象调用成员过程

一、对象条用成员过程

单例设计模式

一、代码

解决一个类在内存中只存在一个对象

1.禁止其他程序建立该类对象。

2.要在本类中自定义一个对象。

3.对外提供一些访问方式

饿汉式（一般用这个，因为比较安全）

class Single{private Single(){}private static Single p=new Single();public static Single getInstance(){return p;}}

懒汉式（线程不安全，可以加入synchronized关键字，但是效率过低）

class Single{private Single(){}private static Single p=null;public static /*synchronized */Single getInstance(){if(p==null)p=new Single();return p;}}

继承（概述）

一、概述

继承：
1.提高了代码的复用性。
2.让类与类之间产生了关系，有了这个关系，才有了多态的特性
3.java语言中只支持单继承(因为多继承容易带来安全隐患。当多个类中定义了
相同功能，当功能内容不同时，子类对象不确定要运行哪一个.)
但是java保留了多继承的机制，并用另一种体现形式来完成，即多实现。
4.查阅父类功能，创建子类对象使用功能。

注意：千万不要为了获取其他类的功能，简化代码而继承。
必须是类与类之间有所属关系才可以继承。

二、代码

将学生和工人的共性描述提取出来，单独进行描述，
只要让学生和工人与单独描述的这个类有关系就可以了。

class Person {String name;int age}class Student extends Person{//String name;//int age=;void study(){System.out.println("good study");}}class Worker extends Person{//String name;//int age=;void study(){System.out.println("good work");}}

子父类中的变量、方法和构造方法的关系

一、变量的特点

如果子类中出现非私有的同名成员变量时，
子类要访问本类中的变量，用this
子类要访问父类中的同名变量，用super
super的使用和this的使用几乎一致。

二、方法的特点

当子类出现和父类一模一样的函数时，
当子类对象调用该函数，会运行子类函数的内容。
如同父类的函数被覆盖一样。(父类的函数依然存在于内存中，只不过没有运行）
这种情况是函数的另一个特性：重写（覆盖）

覆盖：
1.子类覆盖父类，必须保证子类权限大于等于父类权限。
2. 静态只能覆盖静态。

注意：重写与重载不同。 

三、构造方法的特点

1.在对子类对象进行初始化时，父类的构造函数也会运行，
那是因为子类的构造函数默认第一行有一条隐式的语句super()
super():会访问父类中空参数的构造函数。而且子类中所有的构造函数第一行都是super()

2.为什么子类一定要访问父类中的构造函数？
因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。
所以子类在对象初始化时，要先访问以下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。

注意：super语句一定定义在子类构造函数的第一行。子类的构造函数的第一行也可以用子类的构造函数来代替
父类的构造函数，但是这并不影响对父类变量进行赋值，因为子类的构造函数中总会有一个调用父类的构造函数

四、需要能够理解的代码

class Person{private String name;Person(String name){this.name=name;}void show(){}}class Student extends Person{Student(String name){//super.name=name;super(name);}void method(){super.show();}}

用以帮助理解以上代码的例子

class Person{String name="zhangsan";Person(){};Person(String name){this.name=name;}public String getName(){return this.name;}}class Student extends Person{String name;Student(String name){super(name);}/*public String getName(){return name;}*/}class  ExtendsDemo5{public static void main(String[] args) {Student s=new Student("wqz");String name=s.getName();String name2=s.name;System.out.println(name);//返回wqzSystem.out.println(name2);//返回null}}

final关键字

一、概述

1.可以修饰类

被final修饰的类，不可以被继承。（为了避免被继承，被子类复写功能。）

2.可以修饰方法

被final修饰的方法，不可以被重写

3.可以修饰变量

被final修饰的变量是一个常量，只能赋值一次。既可以修饰成员变量，又可以修饰局部变量。只要这个

模板方法模式

一、代码

什么是模板方法？

答：在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，由该类的子类去完成。

abstract class GetTime{public final void getTime(){long start =System.currentTimeMillis();runCode();long end =System.currentTimeMillis();System.out.println("毫秒："+(end-start));}public abstract void runCode();}class SubTime extends GetTime{public void runcode(){for(int x=0;x<100;x++){System.out.print("x");}}}class  TemplateDemo{public static void main(String[] args) {SubTime st=new SubTime();st.getTime();}}

接口

一、格式

1. interface 接口名字

{

public static final int NUM=3;

public abstract void show();

}

2. 接口中常见定义：常量，抽象方法。

接口里面的常量和抽象方法都有固定的修饰符

常量：public static final 

方法：public abstract

3. class Test    (extends Demo)   implements 接口名字1，接口名字2

{

}

4.接口与接口之间是继承关系

interface A

{}

interface B extends A

{}

interface Inter{public static final NUM=3;public abstract void show();}class Test implements Inter{public void show(){}}class InterfaceDemo {public static void main(String[] args) {Test t=new Test();System.out.println(t.NUM);System.out.println(Test.NUM);System.out.println(Inter.NUM);}}

二、接口的特点

1.接口是对外暴露的规则。

2.接口是程序的功能扩展。

3.接口可以用来多实现

4.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

5.接口与接口之间可以有继承关系

三、接口举例体现

abstract class Student{abstract void study();void sleep(){System.out.println("sleep");}}interface Smoking{void smoke();}class ZhangSan extends Student implements Smoking{void study(){};public void smoke(){};}class Lisi extends Student{void study(){};}class InterfaceDemo {public static void main(String[] args) {System.out.println("Hello World!");}}

Object类

一、概述

Object:是所有对象的直接后者的间接父类，传说中的上帝。
该类中定义的成员，是所有对象都具备的。

二、代码(equals()方法)

class Person{}class Demo{}class Demo1{private int num;Demo1(int num){this.num=num;}public boolean equals(Object obj){if(obj instanceof Demo1){Demo1 d=(Demo1)obj;return this.num==d.num;}elsereturn false;}}class ObjectDemo{public static void main(String[] args) {Demo d1=new Demo();Demo d2=new Demo();Demo d3=d1;Demo1 d4=new Demo1(4);Demo1 d5=new Demo1(4);Demo1 d6=new Demo1(5);Person p=new Person();System.out.println(d1.equals(d2));//falseSystem.out.println(d1.equals(d3));//trueSystem.out.println(d1==d2);//falseSystem.out.println(d1==d3);//trueSystem.out.println(d4.equals(d5));//返回trueSystem.out.println(d4.equals(d6));//返回falseSystem.out.println(d4.equals(p));//返回false//其实,equals()方法比较的就是————地址。}}

三、代码（toSting()方法）

public String toString(){return getClass().getName() + '@' + Integer.toHexString(hashCode());}

包与包之间访问

一、会出现的问题

①PackageDemo.java:6: 错误: 找不到符号
                DemoA a=new DemoA();
                ^
  符号:   类 DemoA
  位置: 类 PackageDemo
PackageDemo.java:6: 错误: 找不到符号
                DemoA a=new DemoA();
                            ^
  符号:   类 DemoA
  位置: 类 PackageDemo


错误原因：类名写错。因为类名的全名是：报名.类名

②PackageDemo.java:6: 错误: 程序包packa不存在
                packa.DemoA a=new packa.DemoA();
                     ^
PackageDemo.java:6: 错误: 程序包packa不存在
                packa.DemoA a=new packa.DemoA();
 
错误原因：packa包不在当前目录下，需要设置classpath,告诉jvm去哪里找指定的packa包


③PackageDemo.java:6: 错误: DemoA在packa中不是公共的; 无法从外部程序包中对其进行访
问
                packa.DemoA a=new packa.DemoA();
                     ^
PackageDemo.java:6: 错误: DemoA在packa中不是公共的; 无法从外部程序包中对其进行访
问
                packa.DemoA a=new packa.DemoA();
                                       

错误原因：有了包范围变大，一个包中的类要被访问，必须要有足够大的权限，所以被访问的类要被public修饰



④PackageDemo.java:6: 错误: DemoA在packa中不是公共的; 无法从外部程序包中对其进行访
问
                packa.DemoA a=new packa.DemoA();
                     ^
PackageDemo.java:6: 错误: DemoA在packa中不是公共的; 无法从外部程序包中对其进行访
问
                packa.DemoA a=new packa.DemoA();


错误原因：类共有后，被访问的成员也要公有，才可以被访问。



总结：
①包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰

②不同包中的子类，还可以直接访问父类中被protected修饰的成员

二、访问权限

包与包之间可以使用的权限只有两种，public和protected

public      protected       defalut      private 
同一个类中 ok ok ok ok
同一个包中 ok ok ok
子类 ok ok
不同包中 ok

三、其他注意事项

一个java文件中，不可以出现两个以上的公有类、或者接口，因为一个类被public修饰后，该java文件的名字必须与该类的名字一致，如果出现两个以上的public类，无法明确该文件的名字与哪个类的名字一致。

基本数据类型——对象包装类

一、概述

基本数据类型对象包装类byteByte*intIntegershortShortlongLongboolean BooleanfloatFloatdoubleDouble*charCharacter基本数据类型对象包装类，1.最常见的作用————用于基本数据类型和字符串类型之间做转换1.1基本数据类型转成字符串基本数据类型+""基本数据类型包装类.toString(基本数据类型值)如：Integer.toString(34);将34整数编程"34"1.2字符串转成基本数据类型xxx a=Xxx.parseXxx(String)如：int a=Integer.parseInt("123");如果int a=Integer.parseInt("a123");会报数字格式异常。Integer i=new Integer("123");int num=i.intValue();2.十进制与其他进制进行转换2.1 十进制转成其他进制二进制：toBinaryString();十六进制：toHexString();八进制:toOctalString();2.2 其他进制转成十进制parseInt(String,radix);例：Integer.parseIn("110",10)

基本数据类型——对象包装类新特性

class  {public static void main(String[] args) {Integer x=4;//JDK1.5以后新特性————自动装箱。即自动完成了new Integer(4);x=x+2;//自动拆箱，变成了int类型，所以能和2进行数学运算。再将所得和，进行装箱赋给x.自动拆箱，实际上是进行了x.intValue()操作。}public static void method(){Integer x=new Integer("123");Integer y=new Integer(123);System.out.println(x==y);//falseSystem.out.println(x.equals(y));//true}public static void method1(){Integer m=128;Integer n=128;System.out.println(m==n);//falseInteger a=127;Integer b=127;System.out.println(a==b);//true//因为数值在byte（-128,127）范围内，对于新特性，如果该数已经存在，则不会开辟新空间。}}