第一天
/**
eclipse快捷键
* 自动补全：alt + /
* 查錯：Ctrl+1
* 刪除一行：Ctrl + d
*
* @author HuaQing
*
*/
/**
* 类：是具有相同特征的一类事物的抽象，是概念意义上的
* 对象：是实际存在的某一类事物，是类的实例化，也称为对象，对象与类是一一对应的
* @author HuaQing
*
*/
/**
* 封装：保护内部数据不被外部修改
* @param args
*/
class Stu{
public int age;
private String name;
public void setAge(int a) {
if(a >= 0 && a < 120) {
age = a;
}
}
public void setName(int name) {
this.name = name;
}
public void tell(){
System.out.println("Im "+name+", I have "+age+" ages.");
}
}
Stu t = new Stu();
t.setAge(-20);
t.setName("夏明");
//编译不通过,private 权限修饰符修饰的对象只能通过内部方法修改；
t.tell();
t.age = 20;
//t.name = "夏明"; //error Name是私有，不能被外部改变
/**
* 1、构造器名字与类名相同
* 2、构造器没有返回值，连void都不能写，由public修饰
* 3、是为正在创建的对象的成员变量赋初值，也就是初始化
* 4、如果没有手动实现一个构造函数，编译器会为代码添加一个默认的无参构造函数，格式：
* public 类名() {
*
* }
* 5、如果手动实现了构造函数，那么默认构造函数就会消失、默认构造方法可以不写出来
* 6、构造器可以重载,重载就是函数名相同，访问权限修饰符相同，
* 但是参数类型不同以及参数个数不同
* 7、当前类继承了父类，构造方法之前会先执行父类构造方法
* @param args
*/
public class Test {
public static void main(String [] args){
Boy boy = new Boy(1);
}
}
class people {
int age;
public People(){
}
public People(int age){
this.age = age;
}
}
class boy {
int age;
public Boy (){
}
public Boy (int age){
this age = age;
}
}
/**
* 重载：方法名相同， 参数个数、参数类型至少有一项不同
* @author HuaQing
*/
/**
* char a[5]; C中
* 1)动态初始化
* 数据类型[] 数组名;————声明一个数组
* 数组名 = new 数据类型[5];——为数组分配内存
* 数组名[0] = 1; ————为数组元素初始化 第一个元素初始化
* int[] a; //声明
a = new int[5];
a[0] = 1;
a[1] = 2;
a[2] = 3;
a[3] = 4;
a[4] = 5;
*2)静态初始化
*数据类型[] 数组名 = new 数据类型[]{1,2,3,4,5};
int[] a = new int[]{30,21,54,20,200};
*/
//二维数组
//数据类型[] 数组名 = new 数据类型[2][]
//第二维是通过new一个数组来实现的，也就是数组的数组
int[][] a = new int[2][];
a[0] = new int[2];//为第一行分配两列
a[1] = new int[3];//为第二行分配3列
a[0][0] = 1;//为每个数组元素单独分配空间
a[0][1] = 2;
自定义数据类型
//使用自定义类型来创建的一维数组
public void m5() {
Stu[] stu = new Stu[2];
stu[0] = new Stu(15, “小明”);
System.out.println(stu[0].age);
}
public void m6() {
Stu stu[][] = new Stu[2][];//定义一个二维数组，指定第一维的长度
stu[0] = new Stu[2];//指定第二维德长度，指定的是第一行的长度
stu[0][0] = new Stu(20,"XXX");//给第一行第一列的元素赋初值
System.out.println(stu[0][0].age + stu[0][0].name);
}
第二天
/**
* this:
* 1)表示的是当前类的对象
* 2)this.XXX 调用的是成员
* 3)this() 调用的是本类中的构造函数，可以指定参数，只能出现在第一行 this(100, “”);
* 4)this不能出现在static修饰的方法中
* @author HuaQing
*
*/
/**
* 继承是通过extends来表示
* 格式：class 子类 extends 父类 class Male extends Person
* 只能继承父类中不私有的成员 !
* @author HuaQing
*
*/
/**
* 继承：Java中只能实现单继承
* @author HuaQing
*
*/
/**
* 访问权限修饰符：
* 1)修饰类 public 默认的(default)
* 2)修饰成员：public protected 默认的 private
* @author HuaQing
*
*/
/**
* super():表示的是调用父类中的无参构造函数，也可以指定参数
* super()必须放在构造函数中的第一行
* 如果没有指定一个父类的构造方法，那么会自动调用父类的无参构造方法
* 相当于你写不写都有
* @author HuaQing
*
*/
/**
* super.成员 this.成员
* 作用 表示调用父类中的成员 表示调用本类中的成员
* super() this()
* 作用 表示的是调用父类中的 调用的是本类中的无参构造函数，也可以指定参数
* 无参构造函数，也可以指定参数
* 作用范围 发生在继承关系中 发生在本类中
* 共同点： this()和super()都出现在构造函数中的第一行，不能同时出现，构造时，出现加载混乱
不能出现在static修饰的函数中(因为 static在先于构造函数之前加载执行，static代码段中无类成的员)；
*
* @author HuaQing
*/
/**static: 修饰的成员是类的属性，可以直接用“类名.成员”(标准的),也可以通过“对象.成员”(非标准的)来调用
* 1)非静态方法中能直接调用静态方法
* 2)静态方法中不能直接调用非静态方法，可以通过“对象.成员”来调用，
* 3)静态方法调用静态方法
*
* static 修饰的代码块称为静态代码块,只要类被加载，就会被调用
* static {
*
* }
* @author HuaQing
*/
/**
* 重写是对父类的函数不满意
*
* 重写： 1)方法名、返回值、参数与父类相同
* 2)访问权限修饰符相同或变大
* @author HuaQing
*
*public > protected > default > private
*
*/
/**
* 重载 重写
* OverLoad Override
*定义 方法名相同，参数个数和类型 方法名、参数、返回值类型与被重写的父类的方法名相同相同
*不同:
*权限修饰符 不受影响 必须相同或者变大
*返回 本类中 继承中
*
*
*/
第三天
/**
*抽象类：Obstruct
*抽象类中才有抽象方法，
*抽象类不能实例化(不能创建对象)，天生用来被子类继承，通过子类实现抽象方法
*每个子类继承抽象类，必须实现父类中的所有抽象方法
*抽象类的子类也可以是抽象类
*抽象类中也可以有普通方法
*/
/**
* == 表示的是比较对象的地址
* equals 比较的是对象中具体的字符串的值
* @param args
*/
/**
* final: 修饰变量 ：这个变量值不可更改, public static final PI,PI是常量
* 修饰方法 ：不能被子类重写
* 修饰类： 这个类不能被继承
* @author HuaQing
*
*/
/**
* 父类引用指向子类对象： Fu fu = new Zi(); 向上转型
* 1)通过父类引用fu调用成员方法时：首先看子类有没有重写该函数，如果有重写，调用的是子类中的，如果没有重写，调用的是父类中的
* 2)通过父类引用fu调用成员变量时，一定是父类中的
* @author HuaQing
*
*向上转型： Animal animal = new Cat(); 拥有子类中重写的方法和父类中的所有成员 animal引用的是重写方法
*向下转型： Cat cat = (Cat) animal; 拥有自累计父类中的所有成员
*/
/**
* 抽象类： abstract
* 1)抽象类不能实例化，天生用来被子类继承，通过子类实现其中抽象方法
* 2)只要一个类中有至少一个抽象方法，那么这个类就是抽象类
* 3)抽象类中存在的成员有成员变量、成员方法、抽象方法
* @author HuaQing
*
*/
/**
* 接口： 常量 抽象方法
* @author HuaQing
*
class Computer implements Mouse,KeyBoards{
public int size;
public String host;
public void seeMovie() {
}
public void playGame() {
}
@Override
public void input() {
}
@Override
public void click() {
}
}
public interface Mouse { 接口里面包含两个成员
public static final int size; //公共常量
public abstract void click(); //公共接口
}
interface KeyBoards {
public abstract void input();
}
interface Erji {
public abstract void listen();
}
*/
第四天
/**
* 内部类：就是在一个类里面再定义一个类
* 内部类分为：成员内部类 局部内部类 嵌套内部类(静态内部类)匿名内部类
*
* @author HuaQing
*
*/
/**
* 局部内部类：定义在方法体内部或者是作用域内
* 只在它存在的那个方法体内部或者作用域内有效
* @author HuaQing
*
//抽象方法中的匿名内部类
public class NoNameClass {
public static void main(String[] args) {
People people = new People() {
@Override
public void sleep() {
System.out.println("匿名内部类");
}
};
people.sleep();
}
}
package com.fs.Test;
interface People {
public abstract void sleep();
}
*/
/**
* 线程的启动方式：
* 1)写一个自己的线程类，继承Thread类，重写run()方法
* 通过自己的线程类的”对象.start()”来启动
* 2)写一个自己的线程类实现runnable接口，重写run()方法
* @author HuaQing
*
*/
/**(1)
* try用来捕获异常 catch用来处理异常
*
* 如果try语句块里发生了异常，就执行catch语句块里的内容
* finally语句块是无论try还是catch里的语句是否执行，它一定会执行，除非在此之前，程序强制退出
*
* try{里面的语句出错信息送给Exception类}
* catch(异常类对象 与 捕获错误信息对比){ 执行出错处理 }
*
/** *饿汉式与懒汉式 * *需要某类对象时懒汉式是需要时才会去new那个类的对象并返回，饿汉式是先与使用之前new对象每次使用时直接使用 *优缺点：懒汉式启动快；但线程不安全，new类时可能同时有多个类去new所需类，且占用较多资源 * 饿汉式启动慢；线程安全； */
扫一扫
2099
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
