java基础<基础知识整理>

时间：2021-08-23 16:16:38

对象的初始化过程

一、对象进行new以后的内存发生了那些事情 java基础<基础知识整理>

对象调用成员过程

一、对象条用成员过程 java基础<基础知识整理>

单例设计模式

一、代码 解决一个类在内存中只存在一个对象 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);//返回wqz
System.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;
}
else
return 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));//false
System.out.println(d1.equals(d3));//true
System.out.println(d1==d2);//false
System.out.println(d1==d3);//true
System.out.println(d4.equals(d5));//返回true
System.out.println(d4.equals(d6));//返回false
System.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
*intInteger
shortShort
longLong
boolean Boolean
floatFloat
doubleDouble
*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);//false
System.out.println(x.equals(y));//true
}


public static void method1()
{
Integer m=128;
Integer n=128;
System.out.println(m==n);//false
Integer a=127;
Integer b=127;
System.out.println(a==b);//true
//因为数值在byte（-128,127）范围内，对于新特性，如果该数已经存在，则不会开辟新空间。
}
}

标签：

相关文章