java基础<基础知识整理>

时间:2022-04-28 19:43:47

对象的初始化过程

一、对象进行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)范围内,对于新特性,如果该数已经存在,则不会开辟新空间。
}
}