1.知识点：
1.代码块
2.内部类
3.继承
4.多态
5.单例设计模式
2.知识点的总结及简单使用：
1.代码块(对象被创建之前会被加载)：
- 格式：
修饰符{
预先加载的内容
}
//如果有修饰符，则一定是static
//例子：
class Test3{
int a;
//代码块（在创建对象之前加载）
{
a = 20;
System.out.println(a);
}
public Test3(){
System.out.println(a);
}
}
打印结果：
20
20
-
静态代码块不能调用成员变量和实例方法，因为在对象被创建之前，代码块已经被预先加载。
-
如果有多个代码块，会出现同一变量可能会出现值覆盖的情况（且代码块没有名字所以一个类尽量只写一个代码块）
2.内部类： -
定义一个类的位置：
-
1.单独创建一个文件管理类
-
2.直接在文件里面 类A的上面和下面创建
-
3.直接在某个类A内部创建一个类（内部类：一个类依附于另一个类）
-
内部类分为静态内部类和普通内部类。
class relativeLayout{
String view;
public void show(float left,float top,float bottom,float right){
LayoutParems layoutParems = new LayoutParems(left,top,right,bottom);
System.out.println("试图：" + view + "显示出来了");
System.out.println("left:" + left +"right:" + right+"top:" + top+"bottom:" + bottom);
System.out.println(layoutParems);
}
//定义一个内部类
public class LayoutParems{
//定义属性
float leftMergin;
float topMergin;
float rightMergin;
float bottomMergin;
public LayoutParems(float leftMergin, float topMergin, float rightMergin,
float bottomMergin){
this.leftMergin = leftMergin;
this.bottomMergin = bottomMergin;
this.topMergin = topMergin;
this.rightMergin = rightMergin;
}
//实现LayoutParems的toString方法
@Override
public String toString() {
return "LayoutParems{" +
"leftMergin=" + leftMergin +
", topMergin=" + topMergin +
", rightMergin=" + rightMergin +
", bottomMergin=" + bottomMergin +
'}';
}
}
}
//调用测试
class testLayout{
public static void main(String[] args){
relativeLayout rl = new relativeLayout();
rl.view = "分享按键";
rl.show(20,20,20,20);
}
}
//打印结果：
left:20.0right:20.0top:20.0bottom:20.0
LayoutParems{leftMergin=20.0, topMergin=20.0, rightMergin=20.0, bottomMergin=20.0}
*非静态的内部类可以访问外部类的属性和方法，例：
public class TestInner{
public static void main(String [] args){
TestInner1 testInner1 = new TestInner1();
testInner1.test();
}
}
class TestInner1 {
int a;
int b;
Inner inner;
//创建内部类
class Inner{
//重写构造方法
public Inner(){
a = 20;
b = 30;
//调用外部方法
show();
}
}
public void test(){
inner = new Inner();
}
public void show(){
System.out.println("a = " + a +" b = " + b);
}
}
打印结果：
a = 20 b = 30
3.封装的三种访问权限：
- 默认为protected：所修饰的属性、方法是私有受保护的，子类可以继承，外部无法使用（外部：以类所在的包为界限，包以外为外部）
- privite:所修饰的属性、方法是私有的，子类无法继承，外部无法使用
- public：所修饰的属性、方法是公共的，子类可以继承，外部可以使用
4. 继承(extends）：
- 作用：获得父类的东西，并且可以在继承过程中增加自己的东西
- Java语言中只能单继承
- 在子类中调用父类的方法或属性，用super调用。
- 如果一个方法，需要完成一个功能，但又不能单独完成，可以有以下两种方法:
1.先调用父类完成一定的功能后再调用子类进行操作
2.先调用子类，再调用父类进行操作 - 父类与子类中有同名的内部类，正常调用父类的那个类会被覆盖（如果一定要用父类的内部类，可以使用全类名来调用）
- 所有的类都是直接或间接地继承于object
- 如果父类有自定义构造方法，子类的构造方法必须显式调用（写出来）父类的构造方法，例：
//Test1:父类
class Test1{
String name;
int age;
//自定义构造方法
public Test1(String name,int age){
this.name = name;
this.age = age;
}
}
//子类：Test2
class Test2 extends Test1{
//显式调用父类的构造方法
public Test2(String name,int age){
super(name,age)；
}
}
5.toString方法：
输出打印一个对象时，要实现toString方法，否则答打印的是对象的地址，例：
public class Test {
public static void main(String[] args){
YK yk = new yk("yk",20);
System.out.println(yk);
}
}
class YK{
String name;
int age;
public YK(String name,int age){
this.age = age;
this.name = name;
}
//toString方法
@Override
public String toString() {
return "yk{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
打印结果：
//没有toString方法的结果：
day6.yk@75b84c92
//有toString方法的结果：
yk{name='yk', age=20}
6.多态:
- 1.同一个方法，在不同的子类中有不同的实现,例：
class Test1{
public void info(){
System.out.println("Test1");
}
}
class Test2 extends Test1{
@Override
public void info(){
System.out.println("Test2 ");
}
}
- 2.如果有继承关系，子类的对象可以用父类变量接收(但反过来不行）
class Test3{
}
class Test4 extends Test3{
}
class Test5{
//用父类Test3来接收子类Test4 的对象
Test3 test = new Test4();
}
7.单例设计模式：
- 1.不予许用户自己创建这个类的一个对象
- 2.操作步骤：a.将构造方法私有化（用private修饰构造方法） b.在自己的类里面提供静态创建对象的方法
- 3.对单例对象的命名：default、sharedInstance、manager
例子：
public class People {
public static void main(String[] args){
//调用单例
Poker.shared.test();
Player.getInstance();
Player p = Player.getInstance();
}
}
//饿汉式单例
class Poker{
//定义一个静态的成员变量,记录这个单例对象
public static final Poker shared = new Poker();
//将构造方法私有化
private Poker(){}
public void test()；
}
}
//懒汉式单例
class Player{
//创建静态变量：
private static Player shared = null;
//私有化构造方法
private Player(){}
// 提供给外部一个访问静态变量的方法
public static Player getInstance() {
//加锁（否则在多线程中可能出错）
Object object = new Object();
synchronized (object){
if (shared == null){
//如果没有就创建一个对象
shared = new Player();
}
}
return shared;
}
}
7.ArrayList数组：
class Test2{
public static void main(String[] args){
ArrayList<People1> people1s = new ArrayList();
//添加数据
People1 xw = new People1();
people1s.add(xw);
//访问数据
People1 xw2 = people1s.get(0);
xw2.name = "小王";
System.out.println(xw.name);
System.out.println(xw2.name);
}
}
class People1{
public String name;
@Override
public String toString() {
return "People1{" +
"name='" + name + '\'' +
'}';
}
}
打印结果：
小王
小王
//ArrayList数组：里面保存的都是对象的引用（指针）
//改变数组里面对象的属性变量，原始对象的值也跟着改变（指向的都是同一个内存空间）
网友评论