上面的文字是这个程序的知识点，下面是一些小程序
1.
A、继承使程序呈现多个状态，使程序更好面对现实世界，更好地解决现实问题。
B、继承中子类可以继承父类的公有方法，但不能对其私有方法进行调用。
C、子类继承父类的方法，比如有两个“哭"、"笑"，但是子类可以选择只对”笑“
这个方法进行表达。
第一个知识点：
class Human
{
public void laugh()
{
System.out.printf("笑");
}
public void cry()
{
System.out.printf("哭");
}
}
class Student extends Human
{
public void doHomework()
{
System.out.printf("做作业");
}
}
public class Test_S
{
public static void main(String[] args)
{
Student s = new Student();
s.laugh();
s.cry();
s.doHomework();
}
}
2、如果你定义的一个有参数的构造函数，必须对其赋值。
class A
{
private int i ;
boolean flag = true;
public A(int j, boolean f)
{ i = j;
flag = f;
}
public void show()
{
System.out.println(i + ", " + flag);
//System.out.println( i +", " + flag ); +号不能随便的改变。
}
public A()
{
System.out.printf("无参构造函数的调用");
}
}
public class Test_R
{
public static void main(String[] args)
{
new A(8,false).show();
new A(9,true).show();//调用无参构造函数。
A aa = new A();//调用无参构造函数
//new A(); 调用不了 无参构造函数。
}
}
1、下面这个函数证明在同一个类中，访问修饰符不没有任何限制的。
2、下面这个函数是一个循环来回调用，在编辑，运算都不会出错，不停的在亚栈。
3、在类中函数中的变量可以不进行初始化。
class A
{
public int i ;
private int j ;
public void f()
{
i = j = 111;
g();
}
private void g()
{
j = i = 222;
f();
}
}
public class Test_Q
{
public static void main(String[] args)
{
A aa = new A();
aa.f();
}
}
1、this指针的应用。this指针带着主调函数的地址，去调用被调函数。
2、这种写法保证的数据的安全性，外部不可以对数据进行修改，增大数据的安全性。
3、this指针只存在非静态成员里。
4、静态的成员可以调用类中其它静态成员的变量（成员）和方法（函数），而不能
访问非静态成员，因为在访问非静态成员时，需要创建以个对象（A aa = new A（））
而在静态成员中，不用创建对象就可以直接访问。
5、总结4的话：静态的不能访问非静态成员；但是非静态可以访问静态成员。
*/
class Student
{
public static int cnt = 0;
private String sname;
private int sage;
public Student()
{
cnt++;
}
public Student(String name, int age)
{
this.sname = name;
this.sage = age;
cnt++;
}
}
public class Test_P
{
public static void main(String[] args)
{
//System.out.println("Student.cnt = ", +Student.cnt);
Student st1 = new Student("zhangsan", 20);
Student st2 = new Student("lisi", 30);
Student st3 = new Student();
System.out.printf("Student类总共构造了%d个对象！\n",Student.cnt);
}
}
1、接口方法不能带有主体
2、接口有两个方法，如果只想调用一个方法，这时应该声明实行类为abstract抽象类，接口的属性是不能修改的，因为是final类型。。
interface It1
{
public void f();
// {
// //System.out.printf("FFFF\n"); //是错误的。
// }
void g();
}
abstract class A implements It1
{
public void f()
{
System.out.printf("AAAA\n");
}
}
class B extends A
{
//如果要实现对接口的覆盖，必须在void前加public
public void g() //必须对接口中得g（）进行覆盖
{
}
}
public class Test_N3
{
public static void main(String[] args)
{
B bb = new B();
bb.f();
System.out.printf("哈哈");
}
}
1、子类是可以调用父类中继承来得公有部分，但前提是子类在继承后，没
有对其继承来的公有方法进行重写，也就是没有对其进行覆盖。
2、如果子类在继承父类公有方法，只是对名字，参数类型应相同，才是对
其的重写。
这样要记住在重写时，访问权限的不同也是一个因素。子类的方法访问
权限一定要高于基类中方法的访问权限，只有这样才能进行覆盖，重写。
public 大与protected
class A
{
protected int f(int i)
{
System.out.printf("AAAA\n");
return 10;
}
}
class B extends A
{
public int f(int i)
{
System.out.printf("BBBB\n");
return 10;
}
}
public class Test_L
{
public static void main(String[] args)
{
B bb = new B();
bb.f(10);
}
}
1、在这个程序中，this指针的应用，当main中aa1调用public A时，
A的this指针指向A，这时将this附加到j上面，j在赋给的i，i在被
show输出，此时，show（A的方法）就知道是谁在调用它。
*/
class A
{
public int i;
public A(int j)
{
i = j;
}
public void show()
{
System.out.println("i = " + i);
}
}
class Test_I
{
public static void main(String[] args)
{
A aa1 = new A(5);
A aa2 = new A(8);
aa1.show();
aa2.show();
}
}
|
|
收藏
淘帖
踩
