回顾:
1.对象内存管理
2.继承
3.super
4.向上造型
问: 构造方法可以继承吗?----不可以
父类的构造方法不是被继承的,而是被调用的
class Aoo{
int a;
Aoo(){
}
void show(){}
}
class Boo extends Aoo{
int b;
Boo(int b){
super();
this.b = b;
}
void say(){}
}
Boo o = new Boo(); //编译错误
笔记:
1.方法的重写:覆盖,改
2.重写(override)与重载(overload)的区别:----常见面试题
1)重写:父子类中,方法名相同,参数列表相同,方法体不同
运行期绑定,根据对象绑定方法(看对象)
2)重载:方法名相同,参数列表不同
编译期绑定,根据参数的类型绑定方法(看类型)
2.package:
1)作用:避免命名冲突
2)可以有层次结构,包名建议所有字母都小写
3)同包中的类可以直接访问
不同包中的类:
3.1)先import声明/引入类,直接访问----建议
3.2)完全限定名: 包名.类名-------不建议
import:
1)作用:声明类、引入类
2)语法: import 包名.类名;
3.访问控制修饰符:
1)public:公共的,任何地方都可以
2)protected:受保护的,本类、子类、同包类
3)默认的:什么也不写,本类、同包类
4)private:私有的,本类
类只能用public或默认的来修饰
类中的成员可以用如上4个来修饰
4.static:静态的
1)修饰成员变量-----静态变量
1.1)属于类的,而不属于对象
1.2)和类的信息一起存储在方法区中,只有一份
1.3)常常通过类名.来访问
1.4)何时用:所有对象的值都一样时
2)修饰方法--------静态方法
2.1)没有隐式的this的传递
2.2)静态方法中不能直接访问实例成员(实例变量、方法)
可以直接访问静态成员(静态成员不需要对象来访问,类名.)
2.3)常常通过类名.来访问
2.4)何时用:方法的操作与对象无关,而仅与参数相关
3)修饰块---------静态块
3.1)在类被加载期间执行
因为类只被加载一次,所以静态块也只执行一次
3.2)何时用:加载静态资源(图片、音频、视频......)
5.final:最终的
1)修饰变量:变量不可被修改
2)修饰方法:方法不可被重写
3)修饰类:类不可被继承
任务:
1.演示方法重写的一大(访问权限)和一小(返回值类型)
作业:
1.理论题
2.操作题
3.打开一个记事本:
访问修饰符小代码
static小代码
final小代码
课本86页最后一个PPT(static final常量)------自学
FinalDemo
CS游戏-------地图
地图这个数据,所有对象都一样,所以做成静态变量(静态资源)
静态块,给静态资源赋值
静态方法:方法的操作仅与参数相关,与对象无关
double a = Math.random();
double b = Math.sqrt(25);
int[] a1 = Arrays.copyOf(a,6);
Arrays.sort(arr);
static void sort(int[] arr){
仅仅是对arr进行升序
}
Math m1 = new Math();
m1.sqrt(25);-----5
Math m2 = new Math();
m2.sqrt(25);-----5
Math m3 = new Math();
m3.sqrt(25);-----5
//方法中访问成员变量前面默认有个this.
普通方法默认都有个this传递过来
静态方法没有隐式的this传递
0:this代表当前对象
1.实例成员必须通过对象.来访问
2.静态方法没有隐式的this传递
没有this,意味着没有对象
没有对象,意味着不能直接访问实例成员
Cell c1 = new Cell(2,5);
c1.drop();
Cell c2 = new Cell(3,6);
c2.drop();
drop()方法的操作与对象相关,所以不能static的
class Cell{
int row;
int col;
static int a;
void drop(){ //有一个默认的this传递过来了
}
void moveLeft(){
}
void moveRight(){
}
String getCellInfo(){
}
static void show(){ //没有this传递的
row++; //编译错误(row只能通过对象.来访问,需要对象的)
a++; //正确的(a可以由类名.来访问,不需要对象)
}
}
Cell c1 = new Cell();
c1.drop();
class Cus{
String cardId;
String cardPwd;
double balance;
static double peri;
}
Cus.peri = "0.65";
class Student{
String name;
int age;
String address;
static String className;
}
Student.className = "JSD1503";
Student zs = new Student();
zs.name = "zhangsan";
zs.age = 25;
zs.address = "廊坊";
Student ls = new Student();
ls.name = "lisi";
ls.age = 26;
ls.address = "山东";
StaticDemo
成员变量分两种:
1.实例变量: 不由static修饰
2.静态变量: 由static修饰
class Aoo{
int a; //实例变量
static int b; //静态变量
}
Aoo.b = 1;
Aoo o = new Aoo();
o.a = 1;
方法区: 类(.class),方法,静态变量(1份)
Aoo o1 = new Aoo();
语法规定:类只能用public和默认的
类中的成员可以用4种访问修饰
内部类-----类中套类
class Aoo{
class Boo{ //内部类
}
}
oo.day04.vis
第一次----不对
第二次----不对
问:我的密码是多少?
pwd密码
public boolean checkPwd(String pwd){
.....一堆验证
return true/false;
}
超市购物-------250元
不光光要保护数据,常常还需要去保护一个功能的实现过程
package p1;
class Aoo{
}
package p2;
class Aoo{
}
package p3;
import p1.Aoo;
import p2.Aoo;
class Test{
void show(){
p1.Aoo o1 = new p1.Aoo();
p2.Aoo o2 = new p2.Aoo();
}
}
package day02;
import java.util.Scanner;
import java.util.Arrays;
public class Test{
main(){
Scanner scan = new Scanner(System.in);
int num = scan.nextInt();
Arrays.sort(arr);
}
}
民生银行-----上亿的钱java做一套软件
A公司-----A模块
B公司-----B模块
C公司-----C模块
假设A公司项目
abc------Aoo
假设B公司项目
abc------Aoo
包名的命名建议:
域名反写 . 项目名称 . 模块名称
com.tarena . studentmanager . teachermana
com.tarena . studentmanager . studentmana
公司不冲突 项目不冲突 模块不冲突
同包中的类,可以直接访问
不同包中的类,不可以直接访问:
1.import引入类----建议
2.完全限定名----太长了,不建议
package p1;
class Aoo{
}
class Boo{
void show(){
Aoo o = new Aoo();
}
}
package p2;
import p1.Aoo; //声明Aoo类、引用Aoo类
class Coo{
void show(){
Aoo o = new Aoo(); //完全限定名
}
}
重载看类型,重写看对象
void a(Coo o){
o.show(); //调Doo的
}
void a(Doo o){
o.show();
}
Coo o = new Doo(); //向上造型
a(o); ------ 第一个
1000个类------不能同名
java建议,将类都放在包中
同一包中的类,不能同名
.java----.class
编译期时,还没有对象的
OverrideOverloadDemo
Student zs = new Student();
zs.name = "zhangsan";
zs.age = 25;
zs.address = "廊坊";
zs.className = "JSD1503";
zs.sayHi();------姓名,年龄,地址
Teacher wkj = new Teacher();
wkj.name = "wangkejing";
wkj.age = 26;
wkj.address = "佳木斯";
wkj.salary = 5000;
wkj.sayHi();------姓名,年龄,地址
重写的方法被调用时,看对象
Person p1 = new Person();
p1.sayHi(); //----Person的
Student stu = new Student();
stu.sayHi(); //----Student的
Person p2 = new Student(); //向上造型
p2.sayHi(); //----Student的
class Person{
String name;
int age;
String address;
void say(){
System.out.println(name+","+age+","+address);
}
}
class Student extends Person{
String className;
void say(){
System.out.println(name+","+age+","+address+","+className);
}
}
class Teacher extends Person{
double salary;
void say(){
System.out.println(name+","+age+","+address+","+salary);
}
}
class Doctor extends Person{
String level;
}
1.对象内存管理
2.继承
3.super
4.向上造型
问: 构造方法可以继承吗?----不可以
父类的构造方法不是被继承的,而是被调用的
class Aoo{
int a;
Aoo(){
}
void show(){}
}
class Boo extends Aoo{
int b;
Boo(int b){
super();
this.b = b;
}
void say(){}
}
Boo o = new Boo(); //编译错误
笔记:
1.方法的重写:覆盖,改
2.重写(override)与重载(overload)的区别:----常见面试题
1)重写:父子类中,方法名相同,参数列表相同,方法体不同
运行期绑定,根据对象绑定方法(看对象)
2)重载:方法名相同,参数列表不同
编译期绑定,根据参数的类型绑定方法(看类型)
2.package:
1)作用:避免命名冲突
2)可以有层次结构,包名建议所有字母都小写
3)同包中的类可以直接访问
不同包中的类:
3.1)先import声明/引入类,直接访问----建议
3.2)完全限定名: 包名.类名-------不建议
import:
1)作用:声明类、引入类
2)语法: import 包名.类名;
3.访问控制修饰符:
1)public:公共的,任何地方都可以
2)protected:受保护的,本类、子类、同包类
3)默认的:什么也不写,本类、同包类
4)private:私有的,本类
类只能用public或默认的来修饰
类中的成员可以用如上4个来修饰
4.static:静态的
1)修饰成员变量-----静态变量
1.1)属于类的,而不属于对象
1.2)和类的信息一起存储在方法区中,只有一份
1.3)常常通过类名.来访问
1.4)何时用:所有对象的值都一样时
2)修饰方法--------静态方法
2.1)没有隐式的this的传递
2.2)静态方法中不能直接访问实例成员(实例变量、方法)
可以直接访问静态成员(静态成员不需要对象来访问,类名.)
2.3)常常通过类名.来访问
2.4)何时用:方法的操作与对象无关,而仅与参数相关
3)修饰块---------静态块
3.1)在类被加载期间执行
因为类只被加载一次,所以静态块也只执行一次
3.2)何时用:加载静态资源(图片、音频、视频......)
5.final:最终的
1)修饰变量:变量不可被修改
2)修饰方法:方法不可被重写
3)修饰类:类不可被继承
任务:
1.演示方法重写的一大(访问权限)和一小(返回值类型)
作业:
1.理论题
2.操作题
3.打开一个记事本:
访问修饰符小代码
static小代码
final小代码
课本86页最后一个PPT(static final常量)------自学
FinalDemo
CS游戏-------地图
地图这个数据,所有对象都一样,所以做成静态变量(静态资源)
静态块,给静态资源赋值
静态方法:方法的操作仅与参数相关,与对象无关
double a = Math.random();
double b = Math.sqrt(25);
int[] a1 = Arrays.copyOf(a,6);
Arrays.sort(arr);
static void sort(int[] arr){
仅仅是对arr进行升序
}
Math m1 = new Math();
m1.sqrt(25);-----5
Math m2 = new Math();
m2.sqrt(25);-----5
Math m3 = new Math();
m3.sqrt(25);-----5
//方法中访问成员变量前面默认有个this.
普通方法默认都有个this传递过来
静态方法没有隐式的this传递
0:this代表当前对象
1.实例成员必须通过对象.来访问
2.静态方法没有隐式的this传递
没有this,意味着没有对象
没有对象,意味着不能直接访问实例成员
Cell c1 = new Cell(2,5);
c1.drop();
Cell c2 = new Cell(3,6);
c2.drop();
drop()方法的操作与对象相关,所以不能static的
class Cell{
int row;
int col;
static int a;
void drop(){ //有一个默认的this传递过来了
}
void moveLeft(){
}
void moveRight(){
}
String getCellInfo(){
}
static void show(){ //没有this传递的
row++; //编译错误(row只能通过对象.来访问,需要对象的)
a++; //正确的(a可以由类名.来访问,不需要对象)
}
}
Cell c1 = new Cell();
c1.drop();
class Cus{
String cardId;
String cardPwd;
double balance;
static double peri;
}
Cus.peri = "0.65";
class Student{
String name;
int age;
String address;
static String className;
}
Student.className = "JSD1503";
Student zs = new Student();
zs.name = "zhangsan";
zs.age = 25;
zs.address = "廊坊";
Student ls = new Student();
ls.name = "lisi";
ls.age = 26;
ls.address = "山东";
StaticDemo
成员变量分两种:
1.实例变量: 不由static修饰
2.静态变量: 由static修饰
class Aoo{
int a; //实例变量
static int b; //静态变量
}
Aoo.b = 1;
Aoo o = new Aoo();
o.a = 1;
方法区: 类(.class),方法,静态变量(1份)
Aoo o1 = new Aoo();
语法规定:类只能用public和默认的
类中的成员可以用4种访问修饰
内部类-----类中套类
class Aoo{
class Boo{ //内部类
}
}
oo.day04.vis
第一次----不对
第二次----不对
问:我的密码是多少?
pwd密码
public boolean checkPwd(String pwd){
.....一堆验证
return true/false;
}
超市购物-------250元
不光光要保护数据,常常还需要去保护一个功能的实现过程
package p1;
class Aoo{
}
package p2;
class Aoo{
}
package p3;
import p1.Aoo;
import p2.Aoo;
class Test{
void show(){
p1.Aoo o1 = new p1.Aoo();
p2.Aoo o2 = new p2.Aoo();
}
}
package day02;
import java.util.Scanner;
import java.util.Arrays;
public class Test{
main(){
Scanner scan = new Scanner(System.in);
int num = scan.nextInt();
Arrays.sort(arr);
}
}
民生银行-----上亿的钱java做一套软件
A公司-----A模块
B公司-----B模块
C公司-----C模块
假设A公司项目
abc------Aoo
假设B公司项目
abc------Aoo
包名的命名建议:
域名反写 . 项目名称 . 模块名称
com.tarena . studentmanager . teachermana
com.tarena . studentmanager . studentmana
公司不冲突 项目不冲突 模块不冲突
同包中的类,可以直接访问
不同包中的类,不可以直接访问:
1.import引入类----建议
2.完全限定名----太长了,不建议
package p1;
class Aoo{
}
class Boo{
void show(){
Aoo o = new Aoo();
}
}
package p2;
import p1.Aoo; //声明Aoo类、引用Aoo类
class Coo{
void show(){
Aoo o = new Aoo(); //完全限定名
}
}
重载看类型,重写看对象
void a(Coo o){
o.show(); //调Doo的
}
void a(Doo o){
o.show();
}
Coo o = new Doo(); //向上造型
a(o); ------ 第一个
1000个类------不能同名
java建议,将类都放在包中
同一包中的类,不能同名
.java----.class
编译期时,还没有对象的
OverrideOverloadDemo
Student zs = new Student();
zs.name = "zhangsan";
zs.age = 25;
zs.address = "廊坊";
zs.className = "JSD1503";
zs.sayHi();------姓名,年龄,地址
Teacher wkj = new Teacher();
wkj.name = "wangkejing";
wkj.age = 26;
wkj.address = "佳木斯";
wkj.salary = 5000;
wkj.sayHi();------姓名,年龄,地址
重写的方法被调用时,看对象
Person p1 = new Person();
p1.sayHi(); //----Person的
Student stu = new Student();
stu.sayHi(); //----Student的
Person p2 = new Student(); //向上造型
p2.sayHi(); //----Student的
class Person{
String name;
int age;
String address;
void say(){
System.out.println(name+","+age+","+address);
}
}
class Student extends Person{
String className;
void say(){
System.out.println(name+","+age+","+address+","+className);
}
}
class Teacher extends Person{
double salary;
void say(){
System.out.println(name+","+age+","+address+","+salary);
}
}
class Doctor extends Person{
String level;
}