-------------------------------知识点1----------------------------------------
/*
教练和运动员案例(学生分析然后讲解)
乒乓球运动员和篮球运动员。
乒乓球教练和篮球教练。
为了出国交流,跟乒乓球相关的人员都需要学习英语。
请用所学知识:
分析,这个案例中有哪些抽象类,哪些接口,哪些具体类
*/
// 学习英语接口
interface LearnEnglish{
public abstract void learn_english();
}
// 抽象人类
abstract class Person{
private String name;
private int age;
// 无参构造方法
public Person(){}
// 带参构造方法
public Person(String name,int age){
this.name = name;
this.age = age;
}
// 设置姓名
public void setName(String name){
this.name = name;
}
// 获取姓名
public String getName(){
return name;
}
// 设置年龄
public void setAge(int age){
this.age = age;
}
// 获取年龄
public int getAge(){
return age;
}
// 睡觉方法
public void sleep(){
System.out.println("大家都要睡觉");
}
// 吃饭方法
public abstract void eat();
}
// 抽象运动员类
abstract class Athletes extends Person{
// 无参构造方法
public Athletes(){}
// 带参构造方法
public Athletes(String name, int age){
super(name,age);
}
public void eat(){
System.out.println("运动员多吃蛋白质类食物");
}
// 训练方法
public abstract void train();
}
// 抽象教练类
abstract class Coach extends Person{
// 无参构造方法
public Coach(){}
// 带参构造方法
public Coach(String name, int age){
super(name,age);
}
public void eat(){
System.out.println("教练多吃蔬菜");
}
// 教学方法
public abstract void teach();
}
// 具体乒乓球运动员类
class PingPangAthletes extends Athletes implements LearnEnglish {
// 无参构造方法
public PingPangAthletes(){}
// 带参构造方法
public PingPangAthletes(String name, int age){
super(name,age);
}
// 训练方法
public void train(){
System.out.println("训练乒乓球");
}
// 重写学习英语方法
public void learn_english(){
System.out.println("乒乓球运动员学习英语");
}
}
// 具体蓝球运动员类
class BasketballAthletes extends Athletes {
// 无参构造方法
public BasketballAthletes(){}
// 带参构造方法
public BasketballAthletes(String name, int age){
super(name,age);
}
// 训练方法
public void train(){
System.out.println("训练篮球");
}
}
// 具体乒乓球教练
class PingPangCoach extends Coach implements LearnEnglish{
// 无参构造方法
public PingPangCoach(){}
// 带参构造方法
public PingPangCoach(String name, int age){
super(name,age);
}
// 教学方法
public void teach(){
System.out.println("教乒乓球");
}
// 重写学习英语方法
public void learn_english(){
System.out.println("乒乓球教练学习英语");
}
}
// 具体篮球教练
class BasketballCoach extends Coach {
// 无参构造方法
public BasketballCoach(){}
// 带参构造方法
public BasketballCoach(String name, int age){
super(name,age);
}
// 教学方法
public void teach(){
System.out.println("教篮球");
}
}
class InterfaceDemo{
public static void main(String [] args){
// 创建乒乓球运动员对象
PingPangAthletes ppa = new PingPangAthletes();
ppa.setName(“张三”);
ppa.setAge(20);
System.out.println(ppa.getName()+"----"+ppa.getAge());
ppa.eat();
ppa.sleep();
ppa.train();
ppa.learn_english();
System.out.println("---------------------------");
//创建篮球运动员对象
BasketballAthletes ba = new BasketballAthletes ();
ba.setName("李四");
ba.setAge(18);
System.out.println(ba.getName()+"----"+ba.getAge());
ba.eat();
ba.sleep();
ba.train();
System.out.println("---------------------------");
// 创建乒乓球教练对象
PingPangCoach ppc = new PingPangCoach();
ppc.setName("王五乒乓球教练");
ppc.setAge(40);
System.out.println(ppc.getName()+"----"+ppc.getAge());
ppc.eat();
ppc.sleep();
ppc.teach();
ppc.learn_english();
System.out.println("---------------------------");
// 创建篮球教练
BasketballCoach bc = new BasketballCoach();
bc.setName("蔡徐坤篮球球教练");
bc.setAge(30);
System.out.println(bc.getName()+"----"+bc.getAge());
bc.eat();
bc.sleep();
bc.teach();
System.out.println("---------------------------");
}
}
-------------------------------知识点2----------------------------------------
/*
形式参数:
基本类型:
引用参数
类:需要的是该类的对象
抽象方法:需要的是抽象类的子类对象
接口
*/
abstract class Person{
public abstract void study();
}
class PersonDemo{
public void method(Person p){
p.study();
}
}
// 定义一个学生类
class Student extends Person{
public void study(){
System.out.println(“好好学习,天天向上”);
}
}
class PersonTest{
public static void main(String [] args){
//Person p = new Person();
//p.study();
PersonDemo pd = new PersonDemo();
Person p = new Student();
pd.method§;
}
}
-------------------------------知识点3----------------------------------------
/*
形式参数:
基本类型:
引用参数
类:需要的是该类的对象
抽象方法:
接口
*/
class Student{
public void study(){
System.out.println(“good good study”);
}
}
class StudentDemo{
public void method(Student s){
s.study();
}
}
class StudentTest{
public static void main(String [] args){
// 测试study
Student s = new Student();
s.study();
// 测试method方法
StudentDemo s1 = new StudentDemo();
s1.method(s);
}
}
-------------------------------知识点4----------------------------------------
/*
返回值类型
基本类型:简单
引用类型:
类:返回的是该类的对象
抽象类:
接口:
*/
class Student{
public void study(){
System.out.println(“好好学习,天天向上”);
}
}
class StudentDemo{
public Student getStudent(){
return new Student();
}
}
class StudentTest2{
public static void main(String [] args){
StudentDemo sd = new StudentDemo();
sd.getStudent().study(); //错误格式,必须分布接收
Student s = sd.getStudent();
s.study();
}
}
-------------------------------知识点5----------------------------------------
/*
链式编程:
每次调用完毕方法后,返回的是一个对象
*/
class Student{
public void study(){
System.out.println(“good good study ,day day up up”);
}
}
class StudentDemo{
public Student getStudent(){
return new Student();
}
}
class StudentTest3{
public static void main(String [] args){
StudentDemo sd = new StudentDemo();
//Student s = sd.getStudent();
//s.study();
sd.getStudent().study(); // 链式编程
}
}
-------------------------------知识点6----------------------------------------
/*
形式参数:
基本类型:
引用参数
类:需要的是该类的对象
抽象方法:需要的是抽象类的子类对象
接口:改接口的实现类对象
*/
interface Love{
public abstract void love();
}
class LoveDemo {
public void method(Love l){
l.love();
}
}
// 定义一个具体的类
class Teacher implements Love{
public void love(){
System.out.println(“老师爱学习”);
}
}
class TeacherTest{
public static void main(String [] args){
/*
// 创建对象 方式1
LoveDemo ld = new LoveDemo();
ld.love();
*/
// 创建对象 方式2
Love l = new Teacher();
LoveDemo ld = new LoveDemo();
ld.method(l);
}
}
-------------------------------知识点7----------------------------------------
/*
返回值类型
基本类型:简单
引用类型:
类:返回的是该类的对象
抽象类:返回的是该抽象类的子类对象
接口:返回的是该接口实现类的对象
*/
interface Love{
public abstract void love();
}
class TeacherDemo{
public Love getLove(){
//Love l = new Teacher();
//return l;
return new Teacher();
}
}
class Teacher implements Love{
public void love(){
System.out.println(“老师爱学习”);
}
}
class TeacherTest4{
public static void main(String [] args){
// 方式1
Teacher t = new Teacher();
t.love();
// 方式2
TeacherDemo td = new TeacherDemo();
Love l = td.getLove();
l.love();
}
}
-------------------------------知识点8----------------------------------------
/*
包:
1.其实就是文件夹
2.作用
a.把相同的类名放到不同的包中
b.对类进行分类管理
举例:
学生:增加 ,删除,修改,查询
老师:增加 ,删除,修改,查询
方案1:按照功能分
cn.itcast.add
AddStudent
AddTeacher
cn.itcast.delate
DelateStudent
DelateTeacher
cn.itcast.update
UpdateStudent
UpdateTeacher
cn.itcast.find
FindStudent
FindTeacher
方案2:按照模块分
cn.itcast.teacher
AddStudent
DelateStudent
UpdateStudent
FindStudent
cn.itcast.student
AddTeacher
DelateTeacher
UpdateTeacher
FindTeacher
包的定义
package 包名;
多级包用.分开即可
注意事项:
1.package语句必须是程序的第一条可执行的代码
2.package语句在一个java文件中只能有一个
3.如果没有package,默认表示无包名
带包的编译和运行:
1.手动式
a. 编写一个带包的java文件
b.通过javac命令编译该java文件
c.手动创建包名
d.把b步骤的class文件放到c步骤的最底层包
带包运行。
2.自动式
a.编写一个java文件
b.在编译时采用格式
javac -d . HelloWorld.java
c.带包运行
*/
package cn.itcast;
class HelloWorld{
public static void main(String [] args){
System.out.println(“Hello World”);
}
}
-------------------------------知识点9----------------------------------------
/*
修饰符:
权限修饰符:private,默认的,protect,public
状态修饰符:static ,final
抽象类修饰符:abstract
类:
权限修饰符:默认修饰符,public
状态修饰符:final
抽象修饰符:abstract
用的最多的是:public
成员变量:
权限修饰符:private,默认的,protected,public
状态修饰符:static ,final
用的最多的是private
构造方法:
权限修饰符:private,默认的,protected,public
状态修饰符:不允许static,final,abstract
用的最多的是public
权限修饰符:private,默认的,protected,public
状态修饰符:static,abstract,final修饰都可以
用的最多的是public
除此以外的这规则:
成员变量:public static final
成员方法:public static final
public
*/
// 错误: 此处不允许使用修饰符private
// 错误: 此处不允许使用修饰符protected
//错误: 此处不允许使用修饰符static
// 可以final修饰
public class Demo{
}
package com.liuyi;
class Son extends Father{
public static void main(String [] args){
Father f = new Father();
//f.show();
f.show2();
f.show3();
f.show4();
Son s = new Son();
//s.show();
s.show2();
s.show3();
s.show4();
}
}
/*
*/
package cn.qx;
import com.liuyi.Father;
class Son2 extends Father{
public static void main(String [] args){
Father f = new Father();
//f.show();
//f.show2();
//f.show3();
f.show4();
Son2 s = new Son2();
//s.show();
//s.show2();
s.show3();
s.show4();
}
}
package com.liuyi;
class Test{
public static void main(String [] args){
Father f = new Father();
//f.show();
f.show2();
f.show3();
f.show4();
}
}
package cn.qx;
import com.liuyi.Father;
class Test2{
public static void main(String [] args){
Father f = new Father();
//f.show();
//f.show2(); //错误: show2()在Father中不是公共的; 无法从外部程序包中对其进行访问 f.show2();
//f.show3(); // 错误: show3()可以在Father中访问protected
f.show4();
}
}
-------------------------------知识点10----------------------------------------
/*
内部类:把类定义在其他类内部,这个类就成为内部类
举例:在类A中定义一个类B,类B就是内部类。
内部类的访问特点:
1.内部类可以直接访问外部类的成员,包括私有
2.外部类要访问内部类的成员,必须创建对象
*/
class Outer{
private int num = 10;
class Inner{
public void show(){
System.out.println(num);
}
}
public void method(){
// 错误: 找不到符号
//show();
Inner i = new Inner();
i.show();
}
}
class InnerClassDemo{
public static void main(String [] args){
//Outer o = new Outer();
//o.show();
}
}
-------------------------------知识点11----------------------------------------
/*
内部类的位置:
成员位置:在成员位置定义的类,被称为成员内部类
局部位置:在局部位置定义的类,被称为局部内部类。
*/
class Outer{
// 成员位置
/*class Inner{
}*/
public void method(){
//局部位置
class Inner{
}
}
}
class InnerClassDemo2{
public static void main(String [] args){
}
}
-------------------------------知识点12----------------------------------------
/*
成员内部类:
如何直接访问内部成员
外部类.内部类名 对象名 = 外部类对象.内部类对象;
*/
class Outer{
private int num = 10;
class Inner{
public void show(){
System.out.println(num);
}
}
}
class InnerClassDemo3{
public static void main(String [] args){
// 需求:访问Inner类的show方法
//Inner i = new Inner(); 错误: 找不到符号
//i.show();
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
-------------------------------知识点13----------------------------------------
/*
成员内部类的修饰符:
private 为了保证数据的安全性
static 为了方便访问数据
注意:静态修饰的内部类只能引用外部类数据必须用静态类修饰
案例:我有一个人,人有身体,身体内有心脏
class Body{
class Heart{
public void operator{
System.out.println("心脏");
}
}
public void method(){
Heart h = new Heart();
if(如果你是外科医生){
h.operator();
}
}
}
*/
class Outer{
private int num = 10;
private static int num2 = 100;
// 内部类用静态修饰是因为内部类可以看出是外部类的成员
public static class Inner{
public void show(){
//System.out.println(num);
System.out.println(num2);
}
public static void show2(){
//System.out.println(num);
System.out.println(num2);
}
}
}
class InnerClassDemo4{
public static void main(String [] args){
// 使用内部类
// 错误: 限定的新静态类
//Outer.Inner oi = new Outer().new Inner();
//oi.show();
//oi.show2();
// 成员内部类被静态修饰后的访问方式是:
// 格式:外部类名.内部类名 对象名 = new 外部类名.内部类名;
Outer.Inner oi = new Outer.Inner();
oi.show();
oi.show2();
// show2()的另一种方法
Outer.Inner.show2();
}
}
-------------------------------知识点14----------------------------------------
/*
局部内部类
1.可以直接调用外部类成员
2.可以在局部位置,可以创造内部类对象,通过对象调用内部方法,来使用局部功能
面试题:
局部内部类访问局部变量的注意事项?
1.局部内部类访问局部变量必须用final修饰(这里存在bug)
2.为什么?
局部变量是随着方法的调用而调用,随着调用完毕而消失
而对内存的内容并不会立即消失,所以我们用final修饰
*/
class Outer{
private int num = 10;
public void method(){
final int num2 = 100;
class Inner{
public void show(){
System.out.println(num);
System.out.println(num2);
}
}
Inner i = new Inner();
i.show();
}
}
class InnerClassDemo5{
public static void main(String [] args){
//Outer.method().Inner oi = new Outer().method().show();
Outer o = new Outer();
o.method();
}
}
-------------------------------知识点15----------------------------------------
/*
匿名内部类
就是内部类的简化写法
前提: 存在一个类或者接口
这里的类可以是具体类也可以是抽象类。
格式:
new 类名或者接口名(){
重写方法;
}
本质是什么呢?
是一个继承了该类或者实现了该类接口的子类匿名对象。
*/
interface Inter{
public abstract void show();
public abstract void show2();
}
class Outer{
public void method(){
/new Inter(){
public void show(){
System.out.println(“show”);
}
}.show();/
/*
new Inter(){
public void show(){
System.out.println("show");
}
public void show2(){
System.out.println("show2");
}
}.show();
new Inter(){
public void show(){
System.out.println("show");
}
public void show2(){
System.out.println("show2");
}
}.show2();*/
// 如果我是多个方法,就很麻烦
Inter i = new Inter(){
public void show(){
System.out.println("show");
}
public void show2(){
System.out.println("show2");
}
};
i.show();
i.show2();
}
}
class InnerClassDemo6{
public static void main(String [] args){
Outer o = new Outer();
o.method();
}
}
-------------------------------知识点16----------------------------------------
/*
面试题:
要求请填空分别输出30,20,10;
注意:
1.内部类和外部类没有继承关系
2.通过外部类名限定this对象
Outer.this
*/
class Outer{
public int num = 10;
class Inner{
public int num = 20;
public void show(){
int num = 30;
System.out.println(num);
System.out.println(this.num);
//System.out.println(new Outer().num);
System.out.println(Outer.this.num);
}
}
}
class InnerClassTest{
public static void main(String [] args){
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
-------------------------------知识点17----------------------------------------
/*
匿名内部类在开发中的使用
*/
interface Person{
public abstract void study();
}
class PersonDemo{
// 接口名作为形式参数
// 其实这里是需要的不是接口,而是该接口实现类对象
public void method(Person p){
p.study();
}
}
//实现类
class Student implements Person{
public void study(){
System.out.println(“好好学习,天天向上”);
}
}
class InnerClassTest2{
public static void main(String [] args){
// 测试
PersonDemo pd = new PersonDemo();
Person p = new Student();
pd.method§;
System.out.println("--------------------");
// 匿名内部类在开发中的使用
// 匿名内部类的本质是继承类或者实现了接口的子类匿名对象
pd.method(new Person(){
public void study(){
System.out.println("好好学习,天天向上");
}
});
}
}
-------------------------------day_10 总结----------------------------------------
1:形式参数和返回值的问题(理解)
(1)形式参数:
类名:需要该类的对象
抽象类名:需要该类的子类对象
接口名:需要该接口的实现类对象
(2)返回值类型:
类名:返回的是该类的对象
抽象类名:返回的是该类的子类对象
接口名:返回的是该接口的实现类的对象
(3)链式编程
对象.方法1().方法2()…方法n();
这种用法:其实在方法1()调用完毕后,应该一个对象;
方法2()调用完毕后,应该返回一个对象。
方法n()调用完毕后,可能是对象,也可以不是对象。
2:包(理解)
(1)其实就是文件夹
(2)作用:
A:区分同名的类
B:对类进行分类管理
a:按照功能分
b:按照模块分
(3)包的定义(掌握)
package 包名;
多级包用.分开。
(4)注意事项:(掌握)
A:package语句必须在文件中的第一条有效语句
B:在一个java文件中,只能有一个package
C:如果没有package,默认就是无包名
(5)带包的编译和运行
A:手动式
B:自动式(掌握)
javac -d . HelloWorld.java
3:导包(掌握)
(1)我们多次使用一个带包的类,非常的麻烦,这个时候,Java就提供了一个关键字import。
(2)格式:
import 包名…类名;
另一种:
import 包名…*;(不建议)
(3)package,import,class的顺序
package > import > class
4:权限修饰符(掌握)
(1)权限修饰符
本类 同一个包下 不同包下的子类 不同包下的无关类
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y
(2)这四种权限修饰符在任意时刻只能出现一种。
public class Demo {}
5:常见的修饰符(理解)
(1)分类:
权限修饰符:private,默认,protected,public
状态修饰符:static,final
抽象修饰符:abstract
(2)常见的类及其组成的修饰
类:
默认,public,final,abstract
常用的:public
成员变量:
private,默认,protected,public,static,final
常用的:private
构造方法:
private,默认,protected,public
常用的:public
成员方法:
private,默认,protected,public,static,final,abstract
常用的:public
(3)另外比较常见的:
public static final int X = 10;
public static void show() {}
public final void show() {}
public abstract void show();
6:内部类(理解)
(1)把类定义在另一个类的内部,该类就被称为内部类。
举例:把类B定义在类A中,类B就被称为内部类。
(2)内部类的访问规则
A:可以直接访问外部类的成员,包括私有
B:外部类要想访问内部类成员,必须创建对象
(3)内部类的分类
A:成员内部类
B:局部内部类
(4)成员内部类
A:private 为了数据的安全性
B:static 为了访问的方便性
成员内部类不是静态的:
外部类名.内部类名 对象名 = new 外部类名.new 内部类名();
成员内部类是静态的:
外部类名.内部类名 对象名 = new 外部类名.内部类名();
(5)成员内部类的面试题(填空)
30,20,10
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public viod show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
}
}
}
(6)局部内部类
A:局部内部类访问局部变量必须加final修饰。
B:为什么呢?
因为局部变量使用完毕就消失,而堆内存的数据并不会立即消失。
所以,堆内存还是用该变量,而改变量已经没有了。
为了让该值还存在,就加final修饰。
通过反编译工具我们看到了,加入final后,堆内存直接存储的是值,而不是变量名。
(7)匿名内部类(掌握)
A:是局部内部类的简化形式
B:前提
存在一个类或者接口
C:格式:
new 类名或者接口名() {
重写方法;
}
D:本质:
其实是继承该类或者实现接口的子类匿名对象
(8)匿名内部类在开发中的使用
我们在开发的时候,会看到抽象类,或者接口作为参数。
而这个时候,我们知道实际需要的是一个子类对象。
如果该方法仅仅调用一次,我们就可以使用匿名内部类的格式简化。
interface Person {
public abstract void study();
}
class PersonDemo {
public void method(Person p) {
p.study();
}
}
class PersonTest {
public static void main(String[] args) {
PersonDemo pd = new PersonDemo();
pd.method(new Person() {
public void study() {
System.out.println("好好学习,天天向上");
}
});
}
}
(9)匿名内部类的面试题(补齐代码)
interface Inter {
void show();
}
class Outer {
//补齐代码
public static Inter method() {
return new Inter() {
public void show() {
System.out.println("HelloWorld");
}
};
}
}
class OuterDemo {
public static void main(String[] args) {
Outer.method().show(); //"HelloWorld"
}
}