java实训第十一天8/08

1.修饰符
a)访问修饰符，结合 我们包
public
protected
默认(package)，不写
private
注意：
a)修饰方法和属性的修饰：四个都可以
b)修饰我们的类：public、package
b)修饰符：
final：表示终态
可以修饰的内容：
修饰 类：该类没有子类：
String
System
Math
修饰 变量：(全局和局部)，该变量的值不能修改，常量了
必须提供初始值
public class Test{
public final String name="aaa";

public void show(final int age){//在方法内部age的值不能改变
final double price=12;
}

public void chang(final int[] arrs){
arrs[0]=123;
//错误
arrs=new int[3];
}
}
修饰方法：该方法不能被继承

public class Test{

public final void show(){

}
}
static:表示静态的，就是在类加载的时候解析，和类的生命周期相同
static修饰属性和方法属于类，称为类成员，建议通过类名.的形式访问

修饰属性：该属性被所有对象共享
public class Test{
public static String str;
}

Test.str="";
修饰代码块:静态块
public class Test{

static{
//在类加载的时候执行，只执行一次
//用于加载某些驱动
}

}
修饰 方法：
public class Test{
public void print(){
show();
}
public static void show(){
// 错误
print();
Test t=new Test();
t.print();
}
}
Test.show();

注意：
1.static修饰只能直接方法static修饰的内容
2.static修饰的方法 不能被重写
abstract：表示抽象的
1.修饰类：该类为抽象类，可以包含抽象方法也可以没有
该类不能创建对象
除了可以包含抽象方法和不能创建对象外 和普通的类一样
public abstract class Student{
private String name;
public Student(){

}
public Student(String name){

}
}
继承自该类的子类必须实现其中抽象方法，否子类要变为抽象类
2.修饰方法：该方法不能有方法体，必须以;结束
该种方法要么存放在抽象类中要么存放在接口中
必须在子类中被实现

2.编写一个类要求在内存最多创建该类的 n 个实例
//数据链接池



int[] a={1,2,3,4,5};
for(int i=0;i<a.length;i++){
System.out.println(a[i++]);
}
1 3 5
int[] a={1,2,3,4,5};
for(int i=0;i<a.length;i++){
System.out.println(a[++i]);
}
2 4 下标越界
3.修饰符 中的三个 static final abstract 
static final 可以同时存在
static final String name="";
abstract 不能和其他修饰并存
4.接口：
两类中存在共同的行为，但是不满足 is a 的关系，
还想实现多态，必须使用接口完成多态的实现
就把共有行定义到接口中 在其他类中把该行为实现 即可

5.测试人和车跑的行为


public class Person{
public void run(){
System.out.println("人在以每小时30公里的速度奔跑");//
}
}
public class Car{
public void run(){
System.out.println("车在以每小时300公里的速度奔跑");//
}
}

public class TestFactory{
public void testPerson(Person p){
p.run();
}

public void testCar(Car c){
c.run();
}

}
--接口
--1.接口中方法 都是抽象方法
--2.接口中属性 都是静态常量
接口是常量最佳的存放地点
接口中的属性必须大写两个单词之间 以下划线分割
--3.接口中没有构造方法，不能new
public interface IRun{
int a=12;//public static final int a=12;
public void run();
}
//java中一个类只能继承一个父类，可以实现多个接口 接口之间以逗号分隔
// 先继承后显示  Class extends SuperClass implements 接口1,接口2{}
public class Person implements IRun{
public void run(){
System.out.println("人在以每小时30公里的速度奔跑");//
}
}

public class Car implements IRun{
public void run(){
System.out.println("车在以每小时300公里的速度奔跑");//
}
}

public class TestFactory{
public void test(IRun r){
r.run();
}
}
接口中的行为(方法)越少越好，接口纯洁性(单一职责)


//1.9 beta 
内部测试
公共测试 
正式版本 发布
final版









6.测试程序员和软件工程师及市场人员的工作
  程序员的工作：IT界的民工，面试
写代码
  市场人员：
讲解业务
  软件工程师：技术，表达
写代码
讲解业务：
  
  父类：不行了，只能使用接口代替java中父类实现多态
  
写代码的接口

讲解业务的接口


工程师xx讲解业务
程序员xx在编写代码


7.接口和抽象类的区别：
a)类型不同：
接口是 接口类型 interface
抽象类 类 class 
b)是否包含构造方法
接口中没有构造方法 
抽象类中包含构造方法
c)普通方法
接口中全都是抽象方法
抽象类中可以是抽象方法也可以有普通方法
d)属性
接口中属性 都是 常量 
抽象类中可以有普通的属性
e)继承 
一个类只能继承一个抽象类，可以实现n个接口
8.类可以实现多个接口，但是接口不能继承类
  接口可以继承一个或多个 接口 
  
  接口是否能被继承？
接口可以继承一个或多个 接口，类只能实现一个或多个接口

9.接口继承
public interface A{
int show();
}
public interface B{
String print();
}

public interface C extends A,B{

double add();
}


public class D implements C{
public int show(){
return 0;
}
public String print(){
return "";
}
public double add(){
return 0;
}
}


10.内部类：
一个类的内部 又包含了一个类


public class Outer{
//外部类不能直接访问内部类中的内容，要通过对象访问
class Inner{
//可以访问外部类中的所有内容
}
}
a)静态内部类，被static修饰的类


public class Outer{

static class Inner{

}
}
//在该类的外面访问
Outer.Inner inner=new Outer.Inner();




b)成员内部类，没有static修饰的类
public class Outer{

class Inner{

}
}
//在该类的外面访问
Outer o=new Outer();
Outer.Inner in=o.new Inner();
c)局部内部类，在某个方法中定义的类


public class Outer{

public void show(){

class Inner{

}
}
}
d)匿名内部类，直接new接口的情况
public interface IRun{
public void run();
}

public class Person implements IRun{
public void run(){

}
}

IRun r=new Person();
//匿名内部类
new IRun(){
public void run(){

}
};
//多线程

11.如何在java类中实现多继承，必须使用内部类完成


public abstract class A{

public void print(){

}
}

public abstract class B{
public void show(){

}
}
//通过内部类实现间接继承多个类
public class C {

public void print(){
D d=new D();
d.print();
}

public void show(){
E e=new E();
e.show();
}

class D extends A{
}

class E extends B{
}
}