1. 封装
属性，也叫字段，成员变量
行为： 方法，功能
成员变量有默认值：int 0 ； String null ; boolean false;
*
封装： 封装属性跟实现细节，仅对外提供公共的方法进行访问。
封装属性。
封装方法。
封装构造函数。
*
关键字 对象的 什么什么的 哪个对象调用，就代表哪个对象。
*
*
* return:
返回啥类型，void就变成啥类型。
返回傻子 ，函数就是傻子。
/**
* 这个类主要讲述封装
* @ClassName: Demo1Private.java
* @Description: TODO
* @author Jim老师
* @version jdk8.0
* @Date 2018年8月27日 下午8:16:49
无敌是多么的寂寞
男人不能说不行，不行也得行
*/
/*
* num:属性，也叫字段，成员变量
* 成员变量有默认值：int 0 ； String null ; boolean false;
*
* 封装： 封装属性跟实现细节，仅对外提供公共的方法进行访问。
* 1.封装属性。
* 2.封装方法。
* 3.封装构造函数。
*
* this:关键字 对象的 什么什么的
*
*
* return:
* 1.return 返回啥类型，void就变成啥类型。
* 2.return 返回傻子 ，函数就是傻子。
*
*/
class Car{
private int num; //轮胎数： 2个 3个 4个 6个
private String color; //颜色：
//设置值
public void setNum(int num){ //int a=10;
this.num=num; //
}
//获取值
public int getNum(){
return num;
}
//设置color的颜色
public void setColor(String color){
this.color=color;
}
//获取color的颜色
public String getColor(){
return color;
}
private void show(){
System.out.println("show");
}
public void test(){
show();
}
}
public class Demo1Private {
public static void main(String[] args) {
Car bmw=new Car(); //创建对象，实例化对象，初始化对象
bmw.setNum(10);
int a=bmw.getNum();
System.out.println("a="+a);
bmw.setColor("red");
String color=bmw.getColor();
System.out.println("color="+color);
Car ff=new Car();
int num2=ff.getNum();
String color2=ff.getColor();
System.out.println("num2="+num2+" color2="+color2);
}
}
2. 构造函数
方法的格式：
访问权限修饰符 非静态/静态修饰符 返回值类型 方法名(形式参数类型1 参数名1,。。。。){ }
*
构造方法的格式：
访问权限修饰符 类名(形式参数类型1 参数名1，形式参数类型2 参数名2){
执行的语句
没有return
* }
注意：
构造方法没有静态和非静态之分
构造方法没有void也就是说没有返回值类型
没有return
构造函数名必须跟类名一致。
*
构造函数的特点：
创建对象就是调用构造函数
当一个构造函数都没有的时候，jvm会自动创建空参数的构造函数。
如果有构造函数的时候，jvm就不会自动添加空参数的构造函数。
/**
* 这个类是讲述构造方法
* @ClassName: Demo2Method.java
* @Description: TODO
* @author Jim老师
* @version jdk8.0
* @Date 2018年8月27日 下午9:06:30
无敌是多么的寂寞
男人不能说不行，不行也得行
*/
/*
* 方法的格式：
* 访问权限修饰符 非静态/静态修饰符 返回值类型 方法名(形式参数类型1 参数名1,。。。。){ }
*
* 构造方法的格式：
* 访问权限修饰符 类名(形式参数类型1 参数名1，形式参数类型2 参数名2){
* //执行的语句
* //没有return
* }
* 注意：
* 1.构造方法没有静态和非静态之分
* 2.构造方法没有void也就是说没有返回值类型
* 3.没有return
* 4.构造函数名必须跟类名一致。
*
* 构造函数的特点：
* 1.创建对象就是调用构造函数
* 2.当一个构造函数都没有的时候，jvm会自动创建空参数的构造函数。
* 3.如果有构造函数的时候，jvm就不会自动添加空参数的构造函数。
*
*
*/
class Person{
public Person(int a){ //int a=0;
System.out.println("开宝马X6");
}
public Person(String name,int age){//String name=,int age=19;
System.out.println(name+"开法拉利");
}
public Person(){
System.out.println("开东风悦达起亚");
}
}
public class Demo2Method {
public static void main(String[] args) {
Person jim=new Person(0); //创建对象，实例化对象，初始化对象
new Person(); //
new Person("玖玖",19);
Car2 car=new Car2(12,"黄色");
int num=car.getNum();
String color=car.getColor();
}
}
class Car2{
private int num;
private String color;
public Car2(int num,String color){
this.num=num;
this.color=color;
}
public int getNum(){
return num;
}
public String getColor(){
return color;
}
}
Day08面向对象(二)
1. This
关键字 ， 什么什么的意思 ，哪个对象调用就代表哪个对象。
代表对象。this就只能调用成员
*
特点：
调用属性，也可以调用行为。
调用构造函数。必须是第一行。
不能跟static共存。
*
*
成员：
成员变量：字段，属性
成员函数：行为，功能，方法
*
问题：
对象能调用局部变量吗？不能调用局部变量
对象可以调用成员(成员变量和成员函数)
/**
* 这个类是讲述this关键字
* @ClassName: Demo3This.java
* @Description: TODO
* @author Jim老师
* @version jdk8.0
* @Date 2018年8月27日 下午9:46:33
无敌是多么的寂寞
男人不能说不行，不行也得行
*/
/*
* this: 关键字 ， 什么什么的意思 ，哪个对象调用就代表哪个对象。
* this代表对象。this就只能调用成员
*
* 特点：
* 1.调用属性，也可以调用行为。
* 2.this调用构造函数。必须是第一行。
* 3.this不能跟static共存。
*
*
* 成员：
* 成员变量：字段，属性
* 成员函数：行为，功能，方法
*
* 问题：
* 1.对象能调用局部变量吗？不能调用局部变量
* 对象可以调用成员(成员变量和成员函数)
*
*/
class User{
private String name;
public void setName(String name)
{
this.name=name;
}
private void show(){
System.out.println("show");
}
public void show2(){
show();
System.out.println("show2");
}
public User(){
this(10); //调用构造函数里面参数为int型的函数。
System.out.println("1.开QQ");
}
private User(int a){
System.out.println("2.开奥拓");
}
}
public class Demo3This {
public static void main(String[] args) {
User user=new User();
user.show2();
}
}
2. Static
： 关键字 静态的意思
修饰：
修饰成员： 成员变量 和成员函数
*
特点：
静态函数只能调用静态成员。 非静态函数可以调用静态函数也可以调用非静态函数。
静态成员可以直接被类名调用,也可以被对象调用。
非静态成员只能被对象调用，不能被类名调用。
修饰成员是被共享的。
是随着类的加载而加载。
不能跟this共存。
/**
* 这个类是讲述static
* @ClassName: Demo4Static.java
* @Description: TODO
* @author Jim老师
* @version jdk8.0
* @Date 2018年8月27日 下午10:11:50
无敌是多么的寂寞
男人不能说不行，不行也得行
*/
/*
* static： 关键字 静态的意思
* 修饰：
* 1.修饰成员： 成员变量 和成员函数
*
* 特点：
* 1.静态函数只能调用静态成员。 非静态函数可以调用静态函数也可以调用非静态函数。
* 2.静态成员可以直接被类名调用,也可以被对象调用。非静态成员只能被对象调用，不能被类名调用。
* 3.static修饰成员是被共享的。
* 4.static是随着类的加载而加载。
* 5.static不能跟this共存。
*/
class News{
static String author;
public static void show(){
System.out.println("show");
}
}
public class Demo4Static {
public static void main(String[] args) {
// String string=News.author;
// News.show();
News news1=new News();
news1.author="Jim";
String author=news1.author;
System.out.println("author="+author);
News news2=new News();
String author2=news2.author;
System.out.println("author2="+author2);
// test1();
// System.out.println("title="+title);
}
static String title;
public static void test1(){
System.out.println("test1");
}
public void test2(){
test1();
}
}
3. 继承extends
面向对象的三大特性： 封装，继承，多态
继承的格式：
父类{}
子类 extends 父类{}
*
子类：也叫孩子类，派生类
父类： 也叫超类，基类
/**
* 这个类是讲述继承
* @ClassName: Demo5Extends.java
* @Description: TODO
* @author Jim老师
* @version jdk8.0
* @Date 2018年8月27日 下午10:38:33
无敌是多么的寂寞
男人不能说不行，不行也得行
*/
/*
* 面向对象的三大特性： 封装，继承，多态
* 继承的格式：
* class 父类{}
* class 子类 extends 父类{}
*
* 子类：也叫孩子类，派生类
* 父类： 也叫超类，基类
*/
public class Demo5Extends {
public static void main(String[] args) {
JAVASEStu javaseStu =new JAVASEStu();
javaseStu.study();
}
}
class Stu{
String name;
public void study(){
System.out.println("学习Java!");
}
}
class JAVASEStu extends Stu{
}
/**
* 这个类是讲述继承的特点
* @ClassName: Demo6Extends.java
* @Description: TODO
* @author Jim老师
* @version jdk8.0
* @Date 2018年8月27日 下午10:44:23
无敌是多么的寂寞
男人不能说不行，不行也得行
*/
/*
* 继承的特点：
* 1.一个父类，可以有多个子类。一个子类只能有一个父类
* 2.类与类之间可以有多层关系。
* 3.Java类只支持单继承，不支持多继承，通过另一个方式体现。
*/
public class Demo6Extends {
public static void main(String[] args) {
}
}
class Stu6{
String name;
public void study(){
System.out.println("学习Java!");
}
}
class Person6{
}
class JAVASEStu6 extends Stu6{
}
class ZiJAVASEStu6 extends JAVASEStu6{
}
class JSPStu6 extends Stu6{
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
