/*
单列设计模式:保证类在内存中只有一个对象
如何保证只有一个对象?
1.不能让其他类来创建对象(通常私有化构造函数)
2.在本类中创建好一个对象,对象也是私有化
3.向外提供一个公共的访问方法
*/
//第一种:饿汉模式,类加载的时候就创建对象
class Student
{
private Student()
{
}
private static Student student=new student();//对象
public static Student getStudent()//成员方法
{
return this.student;
}
//私有化了构造函数
//new Student().getStudent();不能调用
//可以通过类名调用Student.getStudent();但前提条件是 static
}
//第二种:懒汉式 ,需要对象的时候才创建
class Student
{
private Student(){}
private Student student=null;//指向的对象是唯一的,但对象的内容是可以改变的
public static Student getStudent()
{
if(student==null)
{
student=new Student;
}
return this.student;
}
}
class SingleDemon1
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
/*
总结:
一.返回值类型
int ,int[],Student(引用类型),
如何确定一个方法我要返回什么类型?让一个方法有什么参数?
需求:根据学生的sid(唯一标识),查询学生信息
参数:sid
返回值:学生.
*/
class Student
{
String sid;
String name;
public void(){}
}
//根据学生的sid查询学生信息
public Student getStudentBySid(String sid)
{
//查询数据库获取学生对象
return student;
}
/*
需求:查询所有学生
参数:未知
返回值:Student[]
*/
public Student[] getStudentList()
{
//查询数据库库中所有的学生
return Student[];
}
//二.getname() setAge(int age)//方法名称不是必须要这么写,这是命名规范
//三.静态 和 非静态
//静态成员变量,类加载的时候就初始化,优先于对象的存在
//创建对象去调用;
// 或 类.静态成员变量
********************************************************************************
<pre name="code" class="java">/*
继承
1.概述:
*/
class A
{
String name;
int age;
public void show()
{
System.out.println("hello");
}
}
class B
{
String name;
int age;
public void show()
{
System.out.println("hello");
}
public void show()
{
System.out.println("生活 你好吗?");
}
}
/*
有没有一种可以将A和B连接在一起 然后将它们之间共同的代码抽出来
有一个类C A和B继承C,那么A有着和C一样的代码,B有着和C一样的代码
*/
class C
{
private String name;//私有化
int age;
public void show()
{
System.out.println("hello");
}
}
//AB如何继承C?
格式?
class A extends C
{
}
class B extends C
{
public void show()
{
System.out.println("生活 你好吗?");
}
}
/*
总结:
1.C称之为父类/超类/基类,(被继承的类)
2.继承的类AB称之为子类/扩展类
3.子类在继承父类,子类可以拥有父类中非私有的所有的成员
为什么要使用继承?
1.提高了代码的复用
2.让类与类之间产生了关系,提供了多态的前提
*/
class Demon2
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
************************************************************************************
<pre name="code" class="java">/*
继承例子
学生类
学号,姓名,年龄
吃饭,睡觉
教师类
教师编号,姓名,年龄
吃饭,睡觉,学习
*/
class Person
{
String name;
int age;
public void eat()
{
System.out.println("吃饭");
}
public void sleep()
{
System.out.println("睡觉");
}
}
class Student extends Person
{
String sid;
}
class Teacher extends Person
{
String tid;
public void study()
{
System.out.println("老师学习");
}
}
class Demon4
{
public static void main(String[] args)
{
//创建父类
Person p=new Person();
p.eat();
p.sleep();
//p.study();//父类不能访问子类的方法
//学生子类
Student s=new Student();
s.eat();
s.sleep();
//老师子类
Teacher t=new Teacher();
t.eat();
t.sleep();
t.study();
}
}
**************************************************************************
<pre name="code" class="java">/*
继承中的成员变量
总结:
1.子类继承父类成员变量 成员属性不一致必定继承
2.子类父类 成员变量名相同 获取本类成员变量的值
如果方法中包含有同名的变量名称,获取的是局部变量.(就近原则)
3.如何获取父类成员,子类成员和局部成员?(成员变量名称一致的情况下)
使用super关键字,和this概念是一致的
*/
class Father
{
int num1=2;//①父类
}
class Son extends Father
{
int num2=5;
int num1=10;//②本类
public void show()
{
int num1=20;//③本方法
System.out.println("num1="+num1);//=③
System.out.println("num1="+this.num1);//=②获取当前类的变量
System.out.println("num1="+super.num1);//=①
System.out.println("num2="+num2);
}
}
class Demon5
{
public static void main(String[] args)
{
Son s=new Son();
s.show();
}
}
*****************************************************************************
<pre name="code" class="java">/*
继承中的成员方法
1.方法名不同 子类直接继承父类中的非私有的方法
2.方法名相同
重写:子类方法名与父类方法名完全一致 简单解释就是重新复写父类继承下来的方法
条件:1.两个方法不是同一个类中
2.方法名称一致
3.重写的方法权限不能低于被重写的方法权限
4.方法的参数类型一致
重载:1.方法名称一致
2.返回类型一致
3.权限一致
4.参数不一致
5.两个方法在同一类中
在子类的重写方法中如何调用父类的方法
super.方法();
静态的方法只能重写静态方法
*/
class Father
{
private void show()//这是私有化的函数,子类无法继承
{
System.out.println("父类打印");
}
public void show1()
{
System.out.println("父类打印1");
}
public static void say()
{
System.out.println("父类说话");
}
}
class Son extends Father
{
//定义一个和父类一致的show()方法
public void show1()
{
//需要调用父类的show1()
super.show1();
System.out.println("子类的打印方法");
}
public void show2()
{
System.out.println("子类自己的方法");
}
//方法名和show1一致,但是参数不一致
public void show1(String name)
{
System.out.println(name+"子类的另一个打印方法");
}
public static void say()
{
System.out.println("子类说话");
}
}
class Demon6
{
public static void main(String[] args)
{
Son son=new Son();
//son.show();
son.show1();
son.show2();
son.show1("斯特恩");
son.say();
}
}
**************************************************************************
<pre name="code" class="java">/*
继承中的构造函数 默认有一个空参数构造函数
子类中默认会有一个super();这行代码
问题:为什么要这么做?
因为子类要继承父类中的成员,那么父类是不是应该先初始化
总结:
this和super有什么区别?
this.成员变量 调用的是本类的成员变量
super.成员变量 调用的是父类的成员变量
this() 调用的是本类的构造函数
super() 调用的是父类的构造函数
this(参数) 调用的是本类的有參构造函数
super(参数) 调用的是父类的有參构造函数
如果父类没有空参构造函数?
那么子类必须调用this(参数) 或 super(参数) 有参数的构造函数才能开始初始化
*/
class Father
{
Father(String name)
{
System.out.println(name+"父类的null构造函数");
}
Father(int num)
{
System.out.println(num+"父类的参数构造函数");
}
}
class Son extends Father
{
Son()//当22行不赋值20时,Demon7.java:19: 错误: 递归构造器调用
{
super(110);
//this(20);
// super();
System.out.println("子类的null参数构造函数");
}
Son(int num)
{
this();
//super("萧华");
//this(12);Demon7.java:50: 错误: 对this的调用必须是构造器中的第一个语句
System.out.println(num+"子类有參构造函数");
}
}
class Demon7
{
public static void main(String[] args)
{
//Father f=new Father();
System.out.println("******************");
Son s=new Son();
}
}
********************************************************************************************
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
